AuroraMiddleware/scuffed-code
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
7f73c4c704
scuffed-code/icu4c/source/i18n/tblcoll.cpp
Syn Wee Quek df6d1549a1 ICU-807 Updated management of length 0 rule string. 
X-SVN-Rev: 4884
2001-06-05 16:26:45 +00:00

803 lines
27 KiB
C++
Raw Blame History

/*
******************************************************************************
* Copyright (C) {1996-2001}, International Business Machines Corporation and *
* others. All Rights Reserved. *
******************************************************************************
*/
/**
* File tblcoll.cpp
*
* Created by: Helena Shih
*
* Modification History:
*
* Date Name Description
* 2/5/97 aliu Added streamIn and streamOut methods. Added
* constructor which reads RuleBasedCollator object from
* a binary file. Added writeToFile method which streams
* RuleBasedCollator out to a binary file. The streamIn
* and streamOut methods use istream and ostream objects
* in binary mode.
* 2/11/97 aliu Moved declarations out of for loop initializer.
* Added Mac compatibility #ifdef for ios::nocreate.
* 2/12/97 aliu Modified to use TableCollationData sub-object to
* hold invariant data.
* 2/13/97 aliu Moved several methods into this class from Collation.
* Added a private RuleBasedCollator(Locale&) constructor,
* to be used by Collator::getInstance(). General
* clean up. Made use of UErrorCode variables consistent.
* 2/20/97 helena Added clone, operator==, operator!=, operator=, and copy
* constructor and getDynamicClassID.
* 3/5/97 aliu Changed compaction cycle to improve performance. We
* use the maximum allowable value which is kBlockCount.
* Modified getRules() to load rules dynamically. Changed
* constructFromFile() call to accomodate this (added
* parameter to specify whether binary loading is to
* take place).
* 05/06/97 helena Added memory allocation error check.
* 6/20/97 helena Java class name change.
* 6/23/97 helena Adding comments to make code more readable.
* 09/03/97 helena Added createCollationKeyValues().
* 06/26/98 erm Changes for CollationKeys using byte arrays.
* 08/10/98 erm Synched with 1.2 version of RuleBasedCollator.java
* 04/23/99 stephen Removed EDecompositionMode, merged with
* Normalizer::EMode
* 06/14/99 stephen Removed kResourceBundleSuffix
* 06/22/99 stephen Fixed logic in constructFromFile() since .ctx
* files are no longer used.
* 11/02/99 helena Collator performance enhancements. Special case
* for NO_OP situations.
* 11/17/99 srl More performance enhancements. Inlined some internal functions.
* 12/15/99 aliu Update to support Thai collation. Move NormalizerIterator
* to implementation file.
* 01/29/01 synwee Modified into a C++ wrapper calling C APIs (ucol.h)
*/
#include "ucol_imp.h"
#include "unicode/tblcoll.h"
#include "unicode/coleitr.h"
#include "uhash.h"
#include "unicode/resbund.h"
#include "cmemory.h"
#ifdef _DEBUG
#include "unistrm.h"
#endif
/* global variable ---------------------------------------------------------- */
/*
synwee : using another name for this
const uint32_t tblcoll_STACK_BUFFER_LENGTH_ = 1024;
*/
#define STACK_BUFFER_LENGTH_ 1024
/* forward declarations ----------------------------------------------------- */
U_CAPI UChar forwardCharIteratorGlue(void *iterator);
/* RuleBasedCollator declaration ----------------------------------------- */
/* ---------------------------------------------------------------------------
The following diagram shows the data structure of the RuleBasedCollator object.
Suppose we have the rule, where 'o-umlaut' is the unicode char 0x00F6.
"a, A < b, B < c, C, ch, cH, Ch, CH < d, D ... < o, O;
'o-umlaut'/E, 'O-umlaut'/E ...".
What the rule says is, sorts 'ch'ligatures and 'c' only with tertiary
difference and sorts 'o-umlaut' as if it's always expanded with 'e'.
mapping table contracting list expanding list
(contains all unicode
char entries) ___ ____________ _________________________
________ |=>|_*_|->|'c' |v('c') | |=>|v('o')|v('umlaut')|v('e')|
|_\u0001_|-> v('\u0001') | |_:_| |------------| | |-------------------------|
|_\u0002_|-> v('\u0002') | |_:_| |'ch'|v('ch')| | | : |
|____:___| | |_:_| |------------| | |-------------------------|
|____:___| | |'cH'|v('cH')| | | : |
|__'a'___|-> v('a') | |------------| | |-------------------------|
|__'b'___|-> v('b') | |'Ch'|v('Ch')| | | : |
|____:___| | |------------| | |-------------------------|
|____:___| | |'CH'|v('CH')| | | : |
|___'c'__|---------------- ------------ | |-------------------------|
|____:___| | | : |
|o-umlaut|---------------------------------------- |_________________________|
|____:___|
--------------------------------------------------------------------------- */
/* public RuleBasedCollator constructor ---------------------------------- */
/**
* Copy constructor
*/
RuleBasedCollator::RuleBasedCollator(const RuleBasedCollator& that) :
Collator(that), dataIsOwned(FALSE), ucollator(that.ucollator),
urulestring(that.urulestring)
{
}
RuleBasedCollator::RuleBasedCollator(const UnicodeString& rules,
UErrorCode& status) :
dataIsOwned(FALSE)
{
if (U_FAILURE(status))
return;
int32_t length = rules.length();
UChar ucharrules[STACK_BUFFER_LENGTH_];
UChar *pucharrules = ucharrules;
if (length >= STACK_BUFFER_LENGTH_)
pucharrules = new UChar[length + 1];
rules.extract(0, length, pucharrules);
pucharrules[length] = 0;
ucollator = ucol_openRules(pucharrules, length, UCOL_DEFAULT_NORMALIZATION,
UCOL_DEFAULT_STRENGTH, &status);
if (U_SUCCESS(status))
{
const UChar *r = ucol_getRules(ucollator, &length);
if (length > 0) {
urulestring = new UnicodeString(r, length);
}
else {
urulestring = new UnicodeString();
}
dataIsOwned = TRUE;
}
if (pucharrules != ucharrules)
delete[] pucharrules;
}
RuleBasedCollator::RuleBasedCollator(const UnicodeString& rules,
ECollationStrength collationStrength,
UErrorCode& status) : dataIsOwned(FALSE)
{
if (U_FAILURE(status))
return;
int32_t length = rules.length();
UChar ucharrules[STACK_BUFFER_LENGTH_];
UChar *pucharrules = ucharrules;
if (length >= STACK_BUFFER_LENGTH_)
pucharrules = new UChar[length + 1];
rules.extract(0, length, pucharrules);
pucharrules[length] = 0;
UCollationStrength strength = getUCollationStrength(collationStrength);
ucollator = ucol_openRules(pucharrules, length, UCOL_DEFAULT_NORMALIZATION,
strength, &status);
if (U_SUCCESS(status))
{
const UChar *r = ucol_getRules(ucollator, &length);
if (length > 0) {
urulestring = new UnicodeString(r, length);
}
else {
urulestring = new UnicodeString();
}
dataIsOwned = TRUE;
}
if (pucharrules != ucharrules)
delete[] pucharrules;
}
RuleBasedCollator::RuleBasedCollator(const UnicodeString& rules,
Normalizer::EMode decompositionMode,
UErrorCode& status) :
dataIsOwned(FALSE)
{
if (U_FAILURE(status))
return;
int32_t length = rules.length();
UChar ucharrules[STACK_BUFFER_LENGTH_];
UChar *pucharrules = ucharrules;
if (length >= STACK_BUFFER_LENGTH_)
pucharrules = new UChar[length + 1];
rules.extract(0, length, pucharrules);
pucharrules[length] = 0;
UNormalizationMode mode = Normalizer::getUNormalizationMode(
decompositionMode, status);
ucollator = ucol_openRules(pucharrules, length, mode,
UCOL_DEFAULT_STRENGTH, &status);
if (U_SUCCESS(status))
{
const UChar *r = ucol_getRules(ucollator, &length);
if (length > 0) {
urulestring = new UnicodeString(r, length);
}
else {
urulestring = new UnicodeString();
}
dataIsOwned = TRUE;
}
if (pucharrules != ucharrules)
delete[] pucharrules;
}
RuleBasedCollator::RuleBasedCollator(const UnicodeString& rules,
ECollationStrength collationStrength,
Normalizer::EMode decompositionMode,
UErrorCode& status) : dataIsOwned(FALSE)
{
if (U_FAILURE(status))
return;
int32_t length = rules.length();
UChar ucharrules[STACK_BUFFER_LENGTH_];
UChar *pucharrules = ucharrules;
if (length >= STACK_BUFFER_LENGTH_)
pucharrules = new UChar[length + 1];
rules.extract(0, length, pucharrules);
pucharrules[length] = 0;
UCollationStrength strength = getUCollationStrength(collationStrength);
UNormalizationMode mode = Normalizer::getUNormalizationMode(
decompositionMode, status);
ucollator = ucol_openRules(pucharrules, length, mode, strength, &status);
if (U_SUCCESS(status))
{
const UChar *r = ucol_getRules(ucollator, &length);
if (length > 0) {
urulestring = new UnicodeString(r, length);
}
else {
urulestring = new UnicodeString();
}
dataIsOwned = TRUE;
}
if (pucharrules != ucharrules)
delete[] pucharrules;
}
/* RuleBasedCollator public destructor ----------------------------------- */
RuleBasedCollator::~RuleBasedCollator()
{
if (dataIsOwned)
{
ucol_close(ucollator);
delete urulestring;
}
ucollator = NULL;
}
/* RuleBaseCollator public methods --------------------------------------- */
UBool RuleBasedCollator::operator==(const Collator& that) const
{
/* only checks for address equals here */
if (Collator::operator==(that))
return TRUE;
if (getDynamicClassID() != that.getDynamicClassID())
return FALSE; /* not the same class */
RuleBasedCollator& thatAlias = (RuleBasedCollator&)that;
/*
synwee : orginal code does not check for data compatibility
*/
if (ucollator != thatAlias.ucollator)
return FALSE;
return TRUE;
}
RuleBasedCollator& RuleBasedCollator::operator=(
const RuleBasedCollator& that)
{
if (this != &that)
{
if (dataIsOwned)
{
ucol_close(ucollator);
ucollator = NULL;
delete urulestring;
}
dataIsOwned = FALSE;
ucollator = that.ucollator;
urulestring = that.urulestring;
}
return *this;
}
Collator* RuleBasedCollator::clone() const
{
return new RuleBasedCollator(*this);
}
/**
* Create a CollationElementIterator object that will iterator over the
* elements in a string, using the collation rules defined in this
* RuleBasedCollator
*/
CollationElementIterator* RuleBasedCollator::createCollationElementIterator
(const UnicodeString& source) const
{
UErrorCode status = U_ZERO_ERROR;
CollationElementIterator *result = new CollationElementIterator(source, this,
status);
if (U_FAILURE(status))
return NULL;
return result;
}
/**
* Create a CollationElementIterator object that will iterator over the
* elements in a string, using the collation rules defined in this
* RuleBasedCollator
*/
CollationElementIterator* RuleBasedCollator::createCollationElementIterator
(const CharacterIterator& source) const
{
UErrorCode status = U_ZERO_ERROR;
CollationElementIterator *result = new CollationElementIterator(source, this,
status);
if (U_FAILURE(status))
return NULL;
return result;
}
/**
* Return a string representation of this collator's rules. The string can
* later be passed to the constructor that takes a UnicodeString argument,
* which will construct a collator that's functionally identical to this one.
* You can also allow users to edit the string in order to change the collation
* data, or you can print it out for inspection, or whatever.
*/
const UnicodeString& RuleBasedCollator::getRules() const
{
return (*urulestring);
}
Collator::EComparisonResult RuleBasedCollator::compare(
const UnicodeString& source,
const UnicodeString& target,
int32_t length) const
{
UnicodeString source_togo;
UnicodeString target_togo;
UTextOffset begin=0;
source.extract(begin, uprv_min(length,source.length()), source_togo);
target.extract(begin, uprv_min(length,target.length()), target_togo);
return compare(source_togo, target_togo);
}
Collator::EComparisonResult RuleBasedCollator::compare(const UChar* source,
int32_t sourceLength,
const UChar* target,
int32_t targetLength)
const
{
return getEComparisonResult(ucol_strcoll(ucollator, source, sourceLength,
target, targetLength));
}
/**
* Compare two strings using this collator
*/
Collator::EComparisonResult RuleBasedCollator::compare(
const UnicodeString& source,
const UnicodeString& target) const
{
UChar uSstart[STACK_BUFFER_LENGTH_];
UChar uTstart[STACK_BUFFER_LENGTH_];
UChar *uSource = uSstart;
UChar *uTarget = uTstart;
uint32_t sourceLen = source.length();
uint32_t targetLen = target.length();
if(sourceLen >= STACK_BUFFER_LENGTH_)
uSource = new UChar[sourceLen+1];
if(targetLen >= STACK_BUFFER_LENGTH_)
uTarget = new UChar[targetLen+1];
source.extract(0, sourceLen, uSource);
uSource[sourceLen] = 0;
target.extract(0, targetLen, uTarget);
uTarget[targetLen] = 0;
EComparisonResult result = compare(uSource, sourceLen, uTarget, targetLen);
if(uSstart != uSource)
delete[] uSource;
if(uTstart != uTarget)
delete[] uTarget;
return result;
}
/**
* Retrieve a collation key for the specified string. The key can be compared
* with other collation keys using a bitwise comparison (e.g. memcmp) to find
* the ordering of their respective source strings. This is handy when doing a
* sort, where each sort key must be compared many times.
*
* The basic algorithm here is to find all of the collation elements for each
* character in the source string, convert them to an ASCII representation, and
* put them into the collation key. But it's trickier than that. Each
* collation element in a string has three components: primary ('A' vs 'B'),
* secondary ('u' vs '<27>'), and tertiary ('A' vs 'a'), and a primary difference
* at the end of a string takes precedence over a secondary or tertiary
* difference earlier in the string.
*
* To account for this, we put all of the primary orders at the beginning of
* the string, followed by the secondary and tertiary orders. Each set of
* orders is terminated by nulls so that a key for a string which is a initial
* substring of another key will compare less without any special case.
*
* Here's a hypothetical example, with the collation element represented as a
* three-digit number, one digit for primary, one for secondary, etc.
*
* String: A a B <20>
* Collation Elements: 101 100 201 511
* Collation Key: 1125<null>0001<null>1011<null>
*
* To make things even trickier, secondary differences (accent marks) are
* compared starting at the *end* of the string in languages with French
* secondary ordering. But when comparing the accent marks on a single base
* character, they are compared from the beginning. To handle this, we reverse
* all of the accents that belong to each base character, then we reverse the
* entire string of secondary orderings at the end.
*/
CollationKey& RuleBasedCollator::getCollationKey(
const UnicodeString& source,
CollationKey& sortkey,
UErrorCode& status) const
{
UChar sStart[STACK_BUFFER_LENGTH_];
UChar *uSource = sStart;
uint32_t sourceLen = source.length();
if(sourceLen >= STACK_BUFFER_LENGTH_)
uSource = new UChar[sourceLen+1];
source.extract(0, sourceLen, uSource);
uSource[sourceLen] = 0;
CollationKey& result = getCollationKey(uSource, sourceLen, sortkey, status);
if(sStart != uSource)
delete[] uSource;
return result;
}
CollationKey& RuleBasedCollator::getCollationKey(const UChar* source,
int32_t sourceLen,
CollationKey& sortkey,
UErrorCode& status) const
{
if (U_FAILURE(status))
{
status = U_ILLEGAL_ARGUMENT_ERROR;
return sortkey.setToBogus();
}
if ((!source) || (sourceLen == 0))
return sortkey.reset();
/*
* have to use malloc, lowest denomination, since adopt can be used by
* a c return value.
*/
uint8_t *result = (uint8_t *)uprv_malloc(UCOL_MAX_BUFFER * sizeof(uint8_t));
int32_t resLen = ucol_getSortKey(ucollator, source, sourceLen, result,
UCOL_MAX_BUFFER);
sortkey.adopt(result, resLen);
return sortkey;
}
/**
* Return the maximum length of any expansion sequences that end with the
* specified comparison order.
* @param order a collation order returned by previous or next.
* @return the maximum length of any expansion seuences ending with the
* specified order or 1 if collation order does not occur at the end of any
* expansion sequence.
* @see CollationElementIterator#getMaxExpansion
*/
int32_t RuleBasedCollator::getMaxExpansion(int32_t order) const
{
uint8_t result;
UCOL_GETMAXEXPANSION(ucollator, (uint32_t)order, result);
return result;
}
uint8_t* RuleBasedCollator::cloneRuleData(int32_t &length,
UErrorCode &status)
{
return ucol_cloneRuleData(ucollator, &length, &status);
}
void RuleBasedCollator::setAttribute(UColAttribute attr,
UColAttributeValue value,
UErrorCode &status)
{
if (U_FAILURE(status))
return;
ucol_setAttribute(ucollator, attr, value, &status);
}
UColAttributeValue RuleBasedCollator::getAttribute(UColAttribute attr,
UErrorCode &status)
{
if (U_FAILURE(status))
return UCOL_DEFAULT;
return ucol_getAttribute(ucollator, attr, &status);
}
Collator* RuleBasedCollator::safeClone(void)
{
UErrorCode intStatus = U_ZERO_ERROR;
int32_t buffersize = U_COL_SAFECLONE_BUFFERSIZE;
UCollator *ucol = ucol_safeClone(ucollator, NULL, &buffersize,
&intStatus);
if (U_FAILURE(intStatus))
return NULL;
int32_t length = 0;
UnicodeString *r = new UnicodeString(ucol_getRules(ucollator, &length),
length);
RuleBasedCollator *result = new RuleBasedCollator(ucol, r);
result->dataIsOwned = TRUE;
return result;
}
Collator::EComparisonResult RuleBasedCollator::compare(
ForwardCharacterIterator &source,
ForwardCharacterIterator &target)
{
return getEComparisonResult(
ucol_strcollinc(ucollator, forwardCharIteratorGlue, &source,
forwardCharIteratorGlue, &target));
}
int32_t RuleBasedCollator::getSortKey(const UnicodeString& source,
uint8_t *result, int32_t resultLength)
const
{
UChar sStart[STACK_BUFFER_LENGTH_];
UChar *uSource = sStart;
uint32_t sourceLen = source.length();
if(sourceLen >= STACK_BUFFER_LENGTH_)
uSource = new UChar[sourceLen+1];
source.extract(0, sourceLen, uSource);
uSource[sourceLen] = 0;
int32_t resLen = ucol_getSortKey(ucollator, uSource, sourceLen, result,
resultLength);
if(sStart != uSource)
delete[] uSource;
return resLen;
}
int32_t RuleBasedCollator::getSortKey(const UChar *source,
int32_t sourceLength, uint8_t *result,
int32_t resultLength) const
{
return ucol_getSortKey(ucollator, source, sourceLength, result, resultLength);
}
Collator::ECollationStrength RuleBasedCollator::getStrength(void) const
{
UErrorCode intStatus = U_ZERO_ERROR;
return getECollationStrength(ucol_getAttribute(ucollator, UCOL_STRENGTH,
&intStatus));
}
void RuleBasedCollator::setStrength(ECollationStrength newStrength)
{
UErrorCode intStatus = U_ZERO_ERROR;
UCollationStrength strength = getUCollationStrength(newStrength);
ucol_setAttribute(ucollator, UCOL_STRENGTH, strength, &intStatus);
}
/**
* Create a hash code for this collation. Just hash the main rule table -- that
* should be good enough for almost any use.
*/
int32_t RuleBasedCollator::hashCode() const
{
int32_t length;
const UChar *rules = ucol_getRules(ucollator, &length);
return uhash_hashUCharsN(rules, length);
}
/**
* Set the decomposition mode of the Collator object. success is equal to
* U_ILLEGAL_ARGUMENT_ERROR if error occurs.
* @param the new decomposition mode
* @see Collator#getDecomposition
*/
void RuleBasedCollator::setDecomposition(Normalizer::EMode mode)
{
UErrorCode status = U_ZERO_ERROR;
ucol_setNormalization(ucollator, Normalizer::getUNormalizationMode(mode,
status));
}
/**
* Get the decomposition mode of the Collator object.
* @return the decomposition mode
* @see Collator#setDecomposition
*/
Normalizer::EMode RuleBasedCollator::getDecomposition(void) const
{
UErrorCode status = U_ZERO_ERROR;
return Normalizer::getNormalizerEMode(ucol_getNormalization(ucollator),
status);
}
// RuleBaseCollatorNew private constructor ----------------------------------
RuleBasedCollator::RuleBasedCollator() : dataIsOwned(FALSE), ucollator(0)
{
}
RuleBasedCollator::RuleBasedCollator(UCollator *collator,
UnicodeString *rule) : dataIsOwned(FALSE)
{
ucollator = collator;
urulestring = rule;
}
RuleBasedCollator::RuleBasedCollator(const Locale& desiredLocale,
UErrorCode& status) :
dataIsOwned(FALSE), ucollator(0)
{
if (U_FAILURE(status))
return;
/*
Try to load, in order:
1. The desired locale's collation.
2. A fallback of the desired locale.
3. The default locale's collation.
4. A fallback of the default locale.
5. The default collation rules, which contains en_US collation rules.
To reiterate, we try:
Specific:
language+country+variant
language+country
language
Default:
language+country+variant
language+country
language
Root: (aka DEFAULTRULES)
steps 1-5 are handled by resource bundle fallback mechanism.
however, in a very unprobable situation that no resource bundle
data exists, step 5 is repeated with hardcoded default rules.
*/
setUCollator(desiredLocale, status);
if (U_FAILURE(status))
{
status = U_ZERO_ERROR;
setUCollator(ResourceBundle::kDefaultFilename, status);
if (U_FAILURE(status))
{
status = U_ZERO_ERROR;
if (status == U_ZERO_ERROR)
status = U_USING_DEFAULT_ERROR;
if (status == U_MEMORY_ALLOCATION_ERROR)
return;
}
}
if (U_SUCCESS(status))
{
int32_t length;
const UChar *r = ucol_getRules(ucollator, &length);
if (length > 0) {
urulestring = new UnicodeString(r, length);
}
else {
urulestring = new UnicodeString();
}
dataIsOwned = TRUE;
}
return;
}
/* RuleBasedCollator private data members -------------------------------- */
/* need look up in .commit() */
const int32_t RuleBasedCollator::CHARINDEX = 0x70000000;
/* Expand index follows */
const int32_t RuleBasedCollator::EXPANDCHARINDEX = 0x7E000000;
/* contract indexes follows */
const int32_t RuleBasedCollator::CONTRACTCHARINDEX = 0x7F000000;
/* unmapped character values */
const int32_t RuleBasedCollator::UNMAPPED = 0xFFFFFFFF;
/* primary strength increment */
const int32_t RuleBasedCollator::PRIMARYORDERINCREMENT = 0x00010000;
/* secondary strength increment */
const int32_t RuleBasedCollator::SECONDARYORDERINCREMENT = 0x00000100;
/* tertiary strength increment */
const int32_t RuleBasedCollator::TERTIARYORDERINCREMENT = 0x00000001;
/* mask off anything but primary order */
const int32_t RuleBasedCollator::PRIMARYORDERMASK = 0xffff0000;
/* mask off anything but secondary order */
const int32_t RuleBasedCollator::SECONDARYORDERMASK = 0x0000ff00;
/* mask off anything but tertiary order */
const int32_t RuleBasedCollator::TERTIARYORDERMASK = 0x000000ff;
/* mask off ignorable char order */
const int32_t RuleBasedCollator::IGNORABLEMASK = 0x0000ffff;
/* use only the primary difference */
const int32_t RuleBasedCollator::PRIMARYDIFFERENCEONLY = 0xffff0000;
/* use only the primary and secondary difference */
const int32_t RuleBasedCollator::SECONDARYDIFFERENCEONLY = 0xffffff00;
/* primary order shift */
const int32_t RuleBasedCollator::PRIMARYORDERSHIFT = 16;
/* secondary order shift */
const int32_t RuleBasedCollator::SECONDARYORDERSHIFT = 8;
/* starting value for collation elements */
const int32_t RuleBasedCollator::COLELEMENTSTART = 0x02020202;
/* testing mask for primary low element */
const int32_t RuleBasedCollator::PRIMARYLOWZEROMASK = 0x00FF0000;
/* reseting value for secondaries and tertiaries */
const int32_t RuleBasedCollator::RESETSECONDARYTERTIARY = 0x00000202;
/* reseting value for tertiaries */
const int32_t RuleBasedCollator::RESETTERTIARY = 0x00000002;
const int32_t RuleBasedCollator::PRIMIGNORABLE = 0x0202;
/* unique file id for parity check */
const int16_t RuleBasedCollator::FILEID = 0x5443;
/* binary collation file extension */
const char* RuleBasedCollator::kFilenameSuffix = ".col";
/* class id ? Value is irrelevant */
char RuleBasedCollator::fgClassID = 0;
/* other methods not belonging to any classes ------------------------------- */
U_CAPI UChar forwardCharIteratorGlue(void *iterator)
{
ForwardCharacterIterator *iter = ((ForwardCharacterIterator *)iterator);
UChar result = iter->nextPostInc();
if (result == ForwardCharacterIterator::DONE)
return 0xFFFF;
else
return result;
}
Reference in New Issue View Git Blame Copy Permalink