lukechilds
/
node
mirror of https://github.com/lukechilds/node.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
15035 Commits
131 Branches
446 Tags
325 MiB
 
 
 
 
 
 
Tree: 039f0c3fc5
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '039f0c3fc5'
${ noResults }
node/deps/icu-small/source/i18n/rulebasedcollator.cpp

1656 lines
60 KiB
Raw Blame History

/*
*******************************************************************************
* Copyright (C) 1996-2015, International Business Machines
* Corporation and others. All Rights Reserved.
*******************************************************************************
* rulebasedcollator.cpp
*
* (replaced the former tblcoll.cpp)
*
* created on: 2012feb14 with new and old collation code
* created by: Markus W. Scherer
*/
#include "unicode/utypes.h"
#if !UCONFIG_NO_COLLATION
#include "unicode/coll.h"
#include "unicode/coleitr.h"
#include "unicode/localpointer.h"
#include "unicode/locid.h"
#include "unicode/sortkey.h"
#include "unicode/tblcoll.h"
#include "unicode/ucol.h"
#include "unicode/uiter.h"
#include "unicode/uloc.h"
#include "unicode/uniset.h"
#include "unicode/unistr.h"
#include "unicode/usetiter.h"
#include "unicode/utf8.h"
#include "unicode/uversion.h"
#include "bocsu.h"
#include "charstr.h"
#include "cmemory.h"
#include "collation.h"
#include "collationcompare.h"
#include "collationdata.h"
#include "collationdatareader.h"
#include "collationfastlatin.h"
#include "collationiterator.h"
#include "collationkeys.h"
#include "collationroot.h"
#include "collationsets.h"
#include "collationsettings.h"
#include "collationtailoring.h"
#include "cstring.h"
#include "uassert.h"
#include "ucol_imp.h"
#include "uhash.h"
#include "uitercollationiterator.h"
#include "ustr_imp.h"
#include "utf16collationiterator.h"
#include "utf8collationiterator.h"
#include "uvectr64.h"
U_NAMESPACE_BEGIN
namespace {
class FixedSortKeyByteSink : public SortKeyByteSink {
public:
FixedSortKeyByteSink(char *dest, int32_t destCapacity)
: SortKeyByteSink(dest, destCapacity) {}
virtual ~FixedSortKeyByteSink();
private:
virtual void AppendBeyondCapacity(const char *bytes, int32_t n, int32_t length);
virtual UBool Resize(int32_t appendCapacity, int32_t length);
};
FixedSortKeyByteSink::~FixedSortKeyByteSink() {}
void
FixedSortKeyByteSink::AppendBeyondCapacity(const char *bytes, int32_t /*n*/, int32_t length) {
// buffer_ != NULL && bytes != NULL && n > 0 && appended_ > capacity_
// Fill the buffer completely.
int32_t available = capacity_ - length;
if (available > 0) {
uprv_memcpy(buffer_ + length, bytes, available);
}
}
UBool
FixedSortKeyByteSink::Resize(int32_t /*appendCapacity*/, int32_t /*length*/) {
return FALSE;
}
} // namespace
// Not in an anonymous namespace, so that it can be a friend of CollationKey.
class CollationKeyByteSink : public SortKeyByteSink {
public:
CollationKeyByteSink(CollationKey &key)
: SortKeyByteSink(reinterpret_cast<char *>(key.getBytes()), key.getCapacity()),
key_(key) {}
virtual ~CollationKeyByteSink();
private:
virtual void AppendBeyondCapacity(const char *bytes, int32_t n, int32_t length);
virtual UBool Resize(int32_t appendCapacity, int32_t length);
CollationKey &key_;
};
CollationKeyByteSink::~CollationKeyByteSink() {}
void
CollationKeyByteSink::AppendBeyondCapacity(const char *bytes, int32_t n, int32_t length) {
// buffer_ != NULL && bytes != NULL && n > 0 && appended_ > capacity_
if (Resize(n, length)) {
uprv_memcpy(buffer_ + length, bytes, n);
}
}
UBool
CollationKeyByteSink::Resize(int32_t appendCapacity, int32_t length) {
if (buffer_ == NULL) {
return FALSE; // allocation failed before already
}
int32_t newCapacity = 2 * capacity_;
int32_t altCapacity = length + 2 * appendCapacity;
if (newCapacity < altCapacity) {
newCapacity = altCapacity;
}
if (newCapacity < 200) {
newCapacity = 200;
}
uint8_t *newBuffer = key_.reallocate(newCapacity, length);
if (newBuffer == NULL) {
SetNotOk();
return FALSE;
}
buffer_ = reinterpret_cast<char *>(newBuffer);
capacity_ = newCapacity;
return TRUE;
}
RuleBasedCollator::RuleBasedCollator(const RuleBasedCollator &other)
: Collator(other),
data(other.data),
settings(other.settings),
tailoring(other.tailoring),
cacheEntry(other.cacheEntry),
validLocale(other.validLocale),
explicitlySetAttributes(other.explicitlySetAttributes),
actualLocaleIsSameAsValid(other.actualLocaleIsSameAsValid) {
settings->addRef();
cacheEntry->addRef();
}
RuleBasedCollator::RuleBasedCollator(const uint8_t *bin, int32_t length,
const RuleBasedCollator *base, UErrorCode &errorCode)
: data(NULL),
settings(NULL),
tailoring(NULL),
cacheEntry(NULL),
validLocale(""),
explicitlySetAttributes(0),
actualLocaleIsSameAsValid(FALSE) {
if(U_FAILURE(errorCode)) { return; }
if(bin == NULL || length == 0 || base == NULL) {
errorCode = U_ILLEGAL_ARGUMENT_ERROR;
return;
}
const CollationTailoring *root = CollationRoot::getRoot(errorCode);
if(U_FAILURE(errorCode)) { return; }
if(base->tailoring != root) {
errorCode = U_UNSUPPORTED_ERROR;
return;
}
LocalPointer<CollationTailoring> t(new CollationTailoring(base->tailoring->settings));
if(t.isNull() || t->isBogus()) {
errorCode = U_MEMORY_ALLOCATION_ERROR;
return;
}
CollationDataReader::read(base->tailoring, bin, length, *t, errorCode);
if(U_FAILURE(errorCode)) { return; }
t->actualLocale.setToBogus();
adoptTailoring(t.orphan(), errorCode);
}
RuleBasedCollator::RuleBasedCollator(const CollationCacheEntry *entry)
: data(entry->tailoring->data),
settings(entry->tailoring->settings),
tailoring(entry->tailoring),
cacheEntry(entry),
validLocale(entry->validLocale),
explicitlySetAttributes(0),
actualLocaleIsSameAsValid(FALSE) {
settings->addRef();
cacheEntry->addRef();
}
RuleBasedCollator::~RuleBasedCollator() {
SharedObject::clearPtr(settings);
SharedObject::clearPtr(cacheEntry);
}
void
RuleBasedCollator::adoptTailoring(CollationTailoring *t, UErrorCode &errorCode) {
if(U_FAILURE(errorCode)) {
t->deleteIfZeroRefCount();
return;
}
U_ASSERT(settings == NULL && data == NULL && tailoring == NULL && cacheEntry == NULL);
cacheEntry = new CollationCacheEntry(t->actualLocale, t);
if(cacheEntry == NULL) {
errorCode = U_MEMORY_ALLOCATION_ERROR;
t->deleteIfZeroRefCount();
return;
}
data = t->data;
settings = t->settings;
settings->addRef();
tailoring = t;
cacheEntry->addRef();
validLocale = t->actualLocale;
actualLocaleIsSameAsValid = FALSE;
}
Collator *
RuleBasedCollator::clone() const {
return new RuleBasedCollator(*this);
}
RuleBasedCollator &RuleBasedCollator::operator=(const RuleBasedCollator &other) {
if(this == &other) { return *this; }
SharedObject::copyPtr(other.settings, settings);
tailoring = other.tailoring;
SharedObject::copyPtr(other.cacheEntry, cacheEntry);
data = tailoring->data;
validLocale = other.validLocale;
explicitlySetAttributes = other.explicitlySetAttributes;
actualLocaleIsSameAsValid = other.actualLocaleIsSameAsValid;
return *this;
}
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(RuleBasedCollator)
UBool
RuleBasedCollator::operator==(const Collator& other) const {
if(this == &other) { return TRUE; }
if(!Collator::operator==(other)) { return FALSE; }
const RuleBasedCollator &o = static_cast<const RuleBasedCollator &>(other);
if(*settings != *o.settings) { return FALSE; }
if(data == o.data) { return TRUE; }
UBool thisIsRoot = data->base == NULL;
UBool otherIsRoot = o.data->base == NULL;
U_ASSERT(!thisIsRoot || !otherIsRoot); // otherwise their data pointers should be ==
if(thisIsRoot != otherIsRoot) { return FALSE; }
if((thisIsRoot || !tailoring->rules.isEmpty()) &&
(otherIsRoot || !o.tailoring->rules.isEmpty())) {
// Shortcut: If both collators have valid rule strings, then compare those.
if(tailoring->rules == o.tailoring->rules) { return TRUE; }
}
// Different rule strings can result in the same or equivalent tailoring.
// The rule strings are optional in ICU resource bundles, although included by default.
// cloneBinary() drops the rule string.
UErrorCode errorCode = U_ZERO_ERROR;
LocalPointer<UnicodeSet> thisTailored(getTailoredSet(errorCode));
LocalPointer<UnicodeSet> otherTailored(o.getTailoredSet(errorCode));
if(U_FAILURE(errorCode)) { return FALSE; }
if(*thisTailored != *otherTailored) { return FALSE; }
// For completeness, we should compare all of the mappings;
// or we should create a list of strings, sort it with one collator,
// and check if both collators compare adjacent strings the same
// (order & strength, down to quaternary); or similar.
// Testing equality of collators seems unusual.
return TRUE;
}
int32_t
RuleBasedCollator::hashCode() const {
int32_t h = settings->hashCode();
if(data->base == NULL) { return h; } // root collator
// Do not rely on the rule string, see comments in operator==().
UErrorCode errorCode = U_ZERO_ERROR;
LocalPointer<UnicodeSet> set(getTailoredSet(errorCode));
if(U_FAILURE(errorCode)) { return 0; }
UnicodeSetIterator iter(*set);
while(iter.next() && !iter.isString()) {
h ^= data->getCE32(iter.getCodepoint());
}
return h;
}
void
RuleBasedCollator::setLocales(const Locale &requested, const Locale &valid,
const Locale &actual) {
if(actual == tailoring->actualLocale) {
actualLocaleIsSameAsValid = FALSE;
} else {
U_ASSERT(actual == valid);
actualLocaleIsSameAsValid = TRUE;
}
// Do not modify tailoring.actualLocale:
// We cannot be sure that that would be thread-safe.
validLocale = valid;
(void)requested; // Ignore, see also ticket #10477.
}
Locale
RuleBasedCollator::getLocale(ULocDataLocaleType type, UErrorCode& errorCode) const {
if(U_FAILURE(errorCode)) {
return Locale::getRoot();
}
switch(type) {
case ULOC_ACTUAL_LOCALE:
return actualLocaleIsSameAsValid ? validLocale : tailoring->actualLocale;
case ULOC_VALID_LOCALE:
return validLocale;
case ULOC_REQUESTED_LOCALE:
default:
errorCode = U_ILLEGAL_ARGUMENT_ERROR;
return Locale::getRoot();
}
}
const char *
RuleBasedCollator::internalGetLocaleID(ULocDataLocaleType type, UErrorCode &errorCode) const {
if(U_FAILURE(errorCode)) {
return NULL;
}
const Locale *result;
switch(type) {
case ULOC_ACTUAL_LOCALE:
result = actualLocaleIsSameAsValid ? &validLocale : &tailoring->actualLocale;
break;
case ULOC_VALID_LOCALE:
result = &validLocale;
break;
case ULOC_REQUESTED_LOCALE:
default:
errorCode = U_ILLEGAL_ARGUMENT_ERROR;
return NULL;
}
if(result->isBogus()) { return NULL; }
const char *id = result->getName();
return id[0] == 0 ? "root" : id;
}
const UnicodeString&
RuleBasedCollator::getRules() const {
return tailoring->rules;
}
void
RuleBasedCollator::getRules(UColRuleOption delta, UnicodeString &buffer) const {
if(delta == UCOL_TAILORING_ONLY) {
buffer = tailoring->rules;
return;
}
// UCOL_FULL_RULES
buffer.remove();
CollationLoader::appendRootRules(buffer);
buffer.append(tailoring->rules).getTerminatedBuffer();
}
void
RuleBasedCollator::getVersion(UVersionInfo version) const {
uprv_memcpy(version, tailoring->version, U_MAX_VERSION_LENGTH);
version[0] += (UCOL_RUNTIME_VERSION << 4) + (UCOL_RUNTIME_VERSION >> 4);
}
UnicodeSet *
RuleBasedCollator::getTailoredSet(UErrorCode &errorCode) const {
if(U_FAILURE(errorCode)) { return NULL; }
UnicodeSet *tailored = new UnicodeSet();
if(tailored == NULL) {
errorCode = U_MEMORY_ALLOCATION_ERROR;
return NULL;
}
if(data->base != NULL) {
TailoredSet(tailored).forData(data, errorCode);
if(U_FAILURE(errorCode)) {
delete tailored;
return NULL;
}
}
return tailored;
}
void
RuleBasedCollator::internalGetContractionsAndExpansions(
UnicodeSet *contractions, UnicodeSet *expansions,
UBool addPrefixes, UErrorCode &errorCode) const {
if(U_FAILURE(errorCode)) { return; }
if(contractions != NULL) {
contractions->clear();
}
if(expansions != NULL) {
expansions->clear();
}
ContractionsAndExpansions(contractions, expansions, NULL, addPrefixes).forData(data, errorCode);
}
void
RuleBasedCollator::internalAddContractions(UChar32 c, UnicodeSet &set, UErrorCode &errorCode) const {
if(U_FAILURE(errorCode)) { return; }
ContractionsAndExpansions(&set, NULL, NULL, FALSE).forCodePoint(data, c, errorCode);
}
const CollationSettings &
RuleBasedCollator::getDefaultSettings() const {
return *tailoring->settings;
}
UColAttributeValue
RuleBasedCollator::getAttribute(UColAttribute attr, UErrorCode &errorCode) const {
if(U_FAILURE(errorCode)) { return UCOL_DEFAULT; }
int32_t option;
switch(attr) {
case UCOL_FRENCH_COLLATION:
option = CollationSettings::BACKWARD_SECONDARY;
break;
case UCOL_ALTERNATE_HANDLING:
return settings->getAlternateHandling();
case UCOL_CASE_FIRST:
return settings->getCaseFirst();
case UCOL_CASE_LEVEL:
option = CollationSettings::CASE_LEVEL;
break;
case UCOL_NORMALIZATION_MODE:
option = CollationSettings::CHECK_FCD;
break;
case UCOL_STRENGTH:
return (UColAttributeValue)settings->getStrength();
case UCOL_HIRAGANA_QUATERNARY_MODE:
// Deprecated attribute, unsettable.
return UCOL_OFF;
case UCOL_NUMERIC_COLLATION:
option = CollationSettings::NUMERIC;
break;
default:
errorCode = U_ILLEGAL_ARGUMENT_ERROR;
return UCOL_DEFAULT;
}
return ((settings->options & option) == 0) ? UCOL_OFF : UCOL_ON;
}
void
RuleBasedCollator::setAttribute(UColAttribute attr, UColAttributeValue value,
UErrorCode &errorCode) {
UColAttributeValue oldValue = getAttribute(attr, errorCode);
if(U_FAILURE(errorCode)) { return; }
if(value == oldValue) {
setAttributeExplicitly(attr);
return;
}
const CollationSettings &defaultSettings = getDefaultSettings();
if(settings == &defaultSettings) {
if(value == UCOL_DEFAULT) {
setAttributeDefault(attr);
return;
}
}
CollationSettings *ownedSettings = SharedObject::copyOnWrite(settings);
if(ownedSettings == NULL) {
errorCode = U_MEMORY_ALLOCATION_ERROR;
return;
}
switch(attr) {
case UCOL_FRENCH_COLLATION:
ownedSettings->setFlag(CollationSettings::BACKWARD_SECONDARY, value,
defaultSettings.options, errorCode);
break;
case UCOL_ALTERNATE_HANDLING:
ownedSettings->setAlternateHandling(value, defaultSettings.options, errorCode);
break;
case UCOL_CASE_FIRST:
ownedSettings->setCaseFirst(value, defaultSettings.options, errorCode);
break;
case UCOL_CASE_LEVEL:
ownedSettings->setFlag(CollationSettings::CASE_LEVEL, value,
defaultSettings.options, errorCode);
break;
case UCOL_NORMALIZATION_MODE:
ownedSettings->setFlag(CollationSettings::CHECK_FCD, value,
defaultSettings.options, errorCode);
break;
case UCOL_STRENGTH:
ownedSettings->setStrength(value, defaultSettings.options, errorCode);
break;
case UCOL_HIRAGANA_QUATERNARY_MODE:
// Deprecated attribute. Check for valid values but do not change anything.
if(value != UCOL_OFF && value != UCOL_ON && value != UCOL_DEFAULT) {
errorCode = U_ILLEGAL_ARGUMENT_ERROR;
}
break;
case UCOL_NUMERIC_COLLATION:
ownedSettings->setFlag(CollationSettings::NUMERIC, value, defaultSettings.options, errorCode);
break;
default:
errorCode = U_ILLEGAL_ARGUMENT_ERROR;
break;
}
if(U_FAILURE(errorCode)) { return; }
setFastLatinOptions(*ownedSettings);
if(value == UCOL_DEFAULT) {
setAttributeDefault(attr);
} else {
setAttributeExplicitly(attr);
}
}
Collator &
RuleBasedCollator::setMaxVariable(UColReorderCode group, UErrorCode &errorCode) {
if(U_FAILURE(errorCode)) { return *this; }
// Convert the reorder code into a MaxVariable number, or UCOL_DEFAULT=-1.
int32_t value;
if(group == UCOL_REORDER_CODE_DEFAULT) {
value = UCOL_DEFAULT;
} else if(UCOL_REORDER_CODE_FIRST <= group && group <= UCOL_REORDER_CODE_CURRENCY) {
value = group - UCOL_REORDER_CODE_FIRST;
} else {
errorCode = U_ILLEGAL_ARGUMENT_ERROR;
return *this;
}
CollationSettings::MaxVariable oldValue = settings->getMaxVariable();
if(value == oldValue) {
setAttributeExplicitly(ATTR_VARIABLE_TOP);
return *this;
}
const CollationSettings &defaultSettings = getDefaultSettings();
if(settings == &defaultSettings) {
if(value == UCOL_DEFAULT) {
setAttributeDefault(ATTR_VARIABLE_TOP);
return *this;
}
}
CollationSettings *ownedSettings = SharedObject::copyOnWrite(settings);
if(ownedSettings == NULL) {
errorCode = U_MEMORY_ALLOCATION_ERROR;
return *this;
}
if(group == UCOL_REORDER_CODE_DEFAULT) {
group = (UColReorderCode)(UCOL_REORDER_CODE_FIRST + defaultSettings.getMaxVariable());
}
uint32_t varTop = data->getLastPrimaryForGroup(group);
U_ASSERT(varTop != 0);
ownedSettings->setMaxVariable(value, defaultSettings.options, errorCode);
if(U_FAILURE(errorCode)) { return *this; }
ownedSettings->variableTop = varTop;
setFastLatinOptions(*ownedSettings);
if(value == UCOL_DEFAULT) {
setAttributeDefault(ATTR_VARIABLE_TOP);
} else {
setAttributeExplicitly(ATTR_VARIABLE_TOP);
}
return *this;
}
UColReorderCode
RuleBasedCollator::getMaxVariable() const {
return (UColReorderCode)(UCOL_REORDER_CODE_FIRST + settings->getMaxVariable());
}
uint32_t
RuleBasedCollator::getVariableTop(UErrorCode & /*errorCode*/) const {
return settings->variableTop;
}
uint32_t
RuleBasedCollator::setVariableTop(const UChar *varTop, int32_t len, UErrorCode &errorCode) {
if(U_FAILURE(errorCode)) { return 0; }
if(varTop == NULL && len !=0) {
errorCode = U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
if(len < 0) { len = u_strlen(varTop); }
if(len == 0) {
errorCode = U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
UBool numeric = settings->isNumeric();
int64_t ce1, ce2;
if(settings->dontCheckFCD()) {
UTF16CollationIterator ci(data, numeric, varTop, varTop, varTop + len);
ce1 = ci.nextCE(errorCode);
ce2 = ci.nextCE(errorCode);
} else {
FCDUTF16CollationIterator ci(data, numeric, varTop, varTop, varTop + len);
ce1 = ci.nextCE(errorCode);
ce2 = ci.nextCE(errorCode);
}
if(ce1 == Collation::NO_CE || ce2 != Collation::NO_CE) {
errorCode = U_CE_NOT_FOUND_ERROR;
return 0;
}
setVariableTop((uint32_t)(ce1 >> 32), errorCode);
return settings->variableTop;
}
uint32_t
RuleBasedCollator::setVariableTop(const UnicodeString &varTop, UErrorCode &errorCode) {
return setVariableTop(varTop.getBuffer(), varTop.length(), errorCode);
}
void
RuleBasedCollator::setVariableTop(uint32_t varTop, UErrorCode &errorCode) {
if(U_FAILURE(errorCode)) { return; }
if(varTop != settings->variableTop) {
// Pin the variable top to the end of the reordering group which contains it.
// Only a few special groups are supported.
int32_t group = data->getGroupForPrimary(varTop);
if(group < UCOL_REORDER_CODE_FIRST || UCOL_REORDER_CODE_CURRENCY < group) {
errorCode = U_ILLEGAL_ARGUMENT_ERROR;
return;
}
uint32_t v = data->getLastPrimaryForGroup(group);
U_ASSERT(v != 0 && v >= varTop);
varTop = v;
if(varTop != settings->variableTop) {
CollationSettings *ownedSettings = SharedObject::copyOnWrite(settings);
if(ownedSettings == NULL) {
errorCode = U_MEMORY_ALLOCATION_ERROR;
return;
}
ownedSettings->setMaxVariable(group - UCOL_REORDER_CODE_FIRST,
getDefaultSettings().options, errorCode);
if(U_FAILURE(errorCode)) { return; }
ownedSettings->variableTop = varTop;
setFastLatinOptions(*ownedSettings);
}
}
if(varTop == getDefaultSettings().variableTop) {
setAttributeDefault(ATTR_VARIABLE_TOP);
} else {
setAttributeExplicitly(ATTR_VARIABLE_TOP);
}
}
int32_t
RuleBasedCollator::getReorderCodes(int32_t *dest, int32_t capacity,
UErrorCode &errorCode) const {
if(U_FAILURE(errorCode)) { return 0; }
if(capacity < 0 || (dest == NULL && capacity > 0)) {
errorCode = U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
int32_t length = settings->reorderCodesLength;
if(length == 0) { return 0; }
if(length > capacity) {
errorCode = U_BUFFER_OVERFLOW_ERROR;
return length;
}
uprv_memcpy(dest, settings->reorderCodes, length * 4);
return length;
}
void
RuleBasedCollator::setReorderCodes(const int32_t *reorderCodes, int32_t length,
UErrorCode &errorCode) {
if(U_FAILURE(errorCode)) { return; }
if(length < 0 || (reorderCodes == NULL && length > 0)) {
errorCode = U_ILLEGAL_ARGUMENT_ERROR;
return;
}
if(length == 1 && reorderCodes[0] == UCOL_REORDER_CODE_NONE) {
length = 0;
}
if(length == settings->reorderCodesLength &&
uprv_memcmp(reorderCodes, settings->reorderCodes, length * 4) == 0) {
return;
}
const CollationSettings &defaultSettings = getDefaultSettings();
if(length == 1 && reorderCodes[0] == UCOL_REORDER_CODE_DEFAULT) {
if(settings != &defaultSettings) {
CollationSettings *ownedSettings = SharedObject::copyOnWrite(settings);
if(ownedSettings == NULL) {
errorCode = U_MEMORY_ALLOCATION_ERROR;
return;
}
ownedSettings->copyReorderingFrom(defaultSettings, errorCode);
setFastLatinOptions(*ownedSettings);
}
return;
}
CollationSettings *ownedSettings = SharedObject::copyOnWrite(settings);
if(ownedSettings == NULL) {
errorCode = U_MEMORY_ALLOCATION_ERROR;
return;
}
ownedSettings->setReordering(*data, reorderCodes, length, errorCode);
setFastLatinOptions(*ownedSettings);
}
void
RuleBasedCollator::setFastLatinOptions(CollationSettings &ownedSettings) const {
ownedSettings.fastLatinOptions = CollationFastLatin::getOptions(
data, ownedSettings,
ownedSettings.fastLatinPrimaries, UPRV_LENGTHOF(ownedSettings.fastLatinPrimaries));
}
UCollationResult
RuleBasedCollator::compare(const UnicodeString &left, const UnicodeString &right,
UErrorCode &errorCode) const {
if(U_FAILURE(errorCode)) { return UCOL_EQUAL; }
return doCompare(left.getBuffer(), left.length(),
right.getBuffer(), right.length(), errorCode);
}
UCollationResult
RuleBasedCollator::compare(const UnicodeString &left, const UnicodeString &right,
int32_t length, UErrorCode &errorCode) const {
if(U_FAILURE(errorCode) || length == 0) { return UCOL_EQUAL; }
if(length < 0) {
errorCode = U_ILLEGAL_ARGUMENT_ERROR;
return UCOL_EQUAL;
}
int32_t leftLength = left.length();
int32_t rightLength = right.length();
if(leftLength > length) { leftLength = length; }
if(rightLength > length) { rightLength = length; }
return doCompare(left.getBuffer(), leftLength,
right.getBuffer(), rightLength, errorCode);
}
UCollationResult
RuleBasedCollator::compare(const UChar *left, int32_t leftLength,
const UChar *right, int32_t rightLength,
UErrorCode &errorCode) const {
if(U_FAILURE(errorCode)) { return UCOL_EQUAL; }
if((left == NULL && leftLength != 0) || (right == NULL && rightLength != 0)) {
errorCode = U_ILLEGAL_ARGUMENT_ERROR;
return UCOL_EQUAL;
}
// Make sure both or neither strings have a known length.
// We do not optimize for mixed length/termination.
if(leftLength >= 0) {
if(rightLength < 0) { rightLength = u_strlen(right); }
} else {
if(rightLength >= 0) { leftLength = u_strlen(left); }
}
return doCompare(left, leftLength, right, rightLength, errorCode);
}
UCollationResult
RuleBasedCollator::compareUTF8(const StringPiece &left, const StringPiece &right,
UErrorCode &errorCode) const {
if(U_FAILURE(errorCode)) { return UCOL_EQUAL; }
const uint8_t *leftBytes = reinterpret_cast<const uint8_t *>(left.data());
const uint8_t *rightBytes = reinterpret_cast<const uint8_t *>(right.data());
if((leftBytes == NULL && !left.empty()) || (rightBytes == NULL && !right.empty())) {
errorCode = U_ILLEGAL_ARGUMENT_ERROR;
return UCOL_EQUAL;
}
return doCompare(leftBytes, left.length(), rightBytes, right.length(), errorCode);
}
UCollationResult
RuleBasedCollator::internalCompareUTF8(const char *left, int32_t leftLength,
const char *right, int32_t rightLength,
UErrorCode &errorCode) const {
if(U_FAILURE(errorCode)) { return UCOL_EQUAL; }
if((left == NULL && leftLength != 0) || (right == NULL && rightLength != 0)) {
errorCode = U_ILLEGAL_ARGUMENT_ERROR;
return UCOL_EQUAL;
}
// Make sure both or neither strings have a known length.
// We do not optimize for mixed length/termination.
if(leftLength >= 0) {
if(rightLength < 0) { rightLength = uprv_strlen(right); }
} else {
if(rightLength >= 0) { leftLength = uprv_strlen(left); }
}
return doCompare(reinterpret_cast<const uint8_t *>(left), leftLength,
reinterpret_cast<const uint8_t *>(right), rightLength, errorCode);
}
namespace {
/**
* Abstract iterator for identical-level string comparisons.
* Returns FCD code points and handles temporary switching to NFD.
*/
class NFDIterator : public UObject {
public:
NFDIterator() : index(-1), length(0) {}
virtual ~NFDIterator() {}
/**
* Returns the next code point from the internal normalization buffer,
* or else the next text code point.
* Returns -1 at the end of the text.
*/
UChar32 nextCodePoint() {
if(index >= 0) {
if(index == length) {
index = -1;
} else {
UChar32 c;
U16_NEXT_UNSAFE(decomp, index, c);
return c;
}
}
return nextRawCodePoint();
}
/**
* @param nfcImpl
* @param c the last code point returned by nextCodePoint() or nextDecomposedCodePoint()
* @return the first code point in c's decomposition,
* or c itself if it was decomposed already or if it does not decompose
*/
UChar32 nextDecomposedCodePoint(const Normalizer2Impl &nfcImpl, UChar32 c) {
if(index >= 0) { return c; }
decomp = nfcImpl.getDecomposition(c, buffer, length);
if(decomp == NULL) { return c; }
index = 0;
U16_NEXT_UNSAFE(decomp, index, c);
return c;
}
protected:
/**
* Returns the next text code point in FCD order.
* Returns -1 at the end of the text.
*/
virtual UChar32 nextRawCodePoint() = 0;
private:
const UChar *decomp;
UChar buffer[4];
int32_t index;
int32_t length;
};
class UTF16NFDIterator : public NFDIterator {
public:
UTF16NFDIterator(const UChar *text, const UChar *textLimit) : s(text), limit(textLimit) {}
protected:
virtual UChar32 nextRawCodePoint() {
if(s == limit) { return U_SENTINEL; }
UChar32 c = *s++;
if(limit == NULL && c == 0) {
s = NULL;
return U_SENTINEL;
}
UChar trail;
if(U16_IS_LEAD(c) && s != limit && U16_IS_TRAIL(trail = *s)) {
++s;
c = U16_GET_SUPPLEMENTARY(c, trail);
}
return c;
}
const UChar *s;
const UChar *limit;
};
class FCDUTF16NFDIterator : public UTF16NFDIterator {
public:
FCDUTF16NFDIterator(const Normalizer2Impl &nfcImpl, const UChar *text, const UChar *textLimit)
: UTF16NFDIterator(NULL, NULL) {
UErrorCode errorCode = U_ZERO_ERROR;
const UChar *spanLimit = nfcImpl.makeFCD(text, textLimit, NULL, errorCode);
if(U_FAILURE(errorCode)) { return; }
if(spanLimit == textLimit || (textLimit == NULL && *spanLimit == 0)) {
s = text;
limit = spanLimit;
} else {
str.setTo(text, (int32_t)(spanLimit - text));
{
ReorderingBuffer buffer(nfcImpl, str);
if(buffer.init(str.length(), errorCode)) {
nfcImpl.makeFCD(spanLimit, textLimit, &buffer, errorCode);
}
}
if(U_SUCCESS(errorCode)) {
s = str.getBuffer();
limit = s + str.length();
}
}
}
private:
UnicodeString str;
};
class UTF8NFDIterator : public NFDIterator {
public:
UTF8NFDIterator(const uint8_t *text, int32_t textLength)
: s(text), pos(0), length(textLength) {}
protected:
virtual UChar32 nextRawCodePoint() {
if(pos == length || (s[pos] == 0 && length < 0)) { return U_SENTINEL; }
UChar32 c;
U8_NEXT_OR_FFFD(s, pos, length, c);
return c;
}
const uint8_t *s;
int32_t pos;
int32_t length;
};
class FCDUTF8NFDIterator : public NFDIterator {
public:
FCDUTF8NFDIterator(const CollationData *data, const uint8_t *text, int32_t textLength)
: u8ci(data, FALSE, text, 0, textLength) {}
protected:
virtual UChar32 nextRawCodePoint() {
UErrorCode errorCode = U_ZERO_ERROR;
return u8ci.nextCodePoint(errorCode);
}
private:
FCDUTF8CollationIterator u8ci;
};
class UIterNFDIterator : public NFDIterator {
public:
UIterNFDIterator(UCharIterator &it) : iter(it) {}
protected:
virtual UChar32 nextRawCodePoint() {
return uiter_next32(&iter);
}
private:
UCharIterator &iter;
};
class FCDUIterNFDIterator : public NFDIterator {
public:
FCDUIterNFDIterator(const CollationData *data, UCharIterator &it, int32_t startIndex)
: uici(data, FALSE, it, startIndex) {}
protected:
virtual UChar32 nextRawCodePoint() {
UErrorCode errorCode = U_ZERO_ERROR;
return uici.nextCodePoint(errorCode);
}
private:
FCDUIterCollationIterator uici;
};
UCollationResult compareNFDIter(const Normalizer2Impl &nfcImpl,
NFDIterator &left, NFDIterator &right) {
for(;;) {
// Fetch the next FCD code point from each string.
UChar32 leftCp = left.nextCodePoint();
UChar32 rightCp = right.nextCodePoint();
if(leftCp == rightCp) {
if(leftCp < 0) { break; }
continue;
}
// If they are different, then decompose each and compare again.
if(leftCp < 0) {
leftCp = -2; // end of string
} else if(leftCp == 0xfffe) {
leftCp = -1; // U+FFFE: merge separator
} else {
leftCp = left.nextDecomposedCodePoint(nfcImpl, leftCp);
}
if(rightCp < 0) {
rightCp = -2; // end of string
} else if(rightCp == 0xfffe) {
rightCp = -1; // U+FFFE: merge separator
} else {
rightCp = right.nextDecomposedCodePoint(nfcImpl, rightCp);
}
if(leftCp < rightCp) { return UCOL_LESS; }
if(leftCp > rightCp) { return UCOL_GREATER; }
}
return UCOL_EQUAL;
}
} // namespace
UCollationResult
RuleBasedCollator::doCompare(const UChar *left, int32_t leftLength,
const UChar *right, int32_t rightLength,
UErrorCode &errorCode) const {
// U_FAILURE(errorCode) checked by caller.
if(left == right && leftLength == rightLength) {
return UCOL_EQUAL;
}
// Identical-prefix test.
const UChar *leftLimit;
const UChar *rightLimit;
int32_t equalPrefixLength = 0;
if(leftLength < 0) {
leftLimit = NULL;
rightLimit = NULL;
UChar c;
while((c = left[equalPrefixLength]) == right[equalPrefixLength]) {
if(c == 0) { return UCOL_EQUAL; }
++equalPrefixLength;
}
} else {
leftLimit = left + leftLength;
rightLimit = right + rightLength;
for(;;) {
if(equalPrefixLength == leftLength) {
if(equalPrefixLength == rightLength) { return UCOL_EQUAL; }
break;
} else if(equalPrefixLength == rightLength ||
left[equalPrefixLength] != right[equalPrefixLength]) {
break;
}
++equalPrefixLength;
}
}
UBool numeric = settings->isNumeric();
if(equalPrefixLength > 0) {
if((equalPrefixLength != leftLength &&
data->isUnsafeBackward(left[equalPrefixLength], numeric)) ||
(equalPrefixLength != rightLength &&
data->isUnsafeBackward(right[equalPrefixLength], numeric))) {
// Identical prefix: Back up to the start of a contraction or reordering sequence.
while(--equalPrefixLength > 0 &&
data->isUnsafeBackward(left[equalPrefixLength], numeric)) {}
}
// Notes:
// - A longer string can compare equal to a prefix of it if only ignorables follow.
// - With a backward level, a longer string can compare less-than a prefix of it.
// Pass the actual start of each string into the CollationIterators,
// plus the equalPrefixLength position,
// so that prefix matches back into the equal prefix work.
}
int32_t result;
int32_t fastLatinOptions = settings->fastLatinOptions;
if(fastLatinOptions >= 0 &&
(equalPrefixLength == leftLength ||
left[equalPrefixLength] <= CollationFastLatin::LATIN_MAX) &&
(equalPrefixLength == rightLength ||
right[equalPrefixLength] <= CollationFastLatin::LATIN_MAX)) {
if(leftLength >= 0) {
result = CollationFastLatin::compareUTF16(data->fastLatinTable,
settings->fastLatinPrimaries,
fastLatinOptions,
left + equalPrefixLength,
leftLength - equalPrefixLength,
right + equalPrefixLength,
rightLength - equalPrefixLength);
} else {
result = CollationFastLatin::compareUTF16(data->fastLatinTable,
settings->fastLatinPrimaries,
fastLatinOptions,
left + equalPrefixLength, -1,
right + equalPrefixLength, -1);
}
} else {
result = CollationFastLatin::BAIL_OUT_RESULT;
}
if(result == CollationFastLatin::BAIL_OUT_RESULT) {
if(settings->dontCheckFCD()) {
UTF16CollationIterator leftIter(data, numeric,
left, left + equalPrefixLength, leftLimit);
UTF16CollationIterator rightIter(data, numeric,
right, right + equalPrefixLength, rightLimit);
result = CollationCompare::compareUpToQuaternary(leftIter, rightIter, *settings, errorCode);
} else {
FCDUTF16CollationIterator leftIter(data, numeric,
left, left + equalPrefixLength, leftLimit);
FCDUTF16CollationIterator rightIter(data, numeric,
right, right + equalPrefixLength, rightLimit);
result = CollationCompare::compareUpToQuaternary(leftIter, rightIter, *settings, errorCode);
}
}
if(result != UCOL_EQUAL || settings->getStrength() < UCOL_IDENTICAL || U_FAILURE(errorCode)) {
return (UCollationResult)result;
}
// Note: If NUL-terminated, we could get the actual limits from the iterators now.
// That would complicate the iterators a bit, NUL-terminated strings are only a C convenience,
// and the benefit seems unlikely to be measurable.
// Compare identical level.
const Normalizer2Impl &nfcImpl = data->nfcImpl;
left += equalPrefixLength;
right += equalPrefixLength;
if(settings->dontCheckFCD()) {
UTF16NFDIterator leftIter(left, leftLimit);
UTF16NFDIterator rightIter(right, rightLimit);
return compareNFDIter(nfcImpl, leftIter, rightIter);
} else {
FCDUTF16NFDIterator leftIter(nfcImpl, left, leftLimit);
FCDUTF16NFDIterator rightIter(nfcImpl, right, rightLimit);
return compareNFDIter(nfcImpl, leftIter, rightIter);
}
}
UCollationResult
RuleBasedCollator::doCompare(const uint8_t *left, int32_t leftLength,
const uint8_t *right, int32_t rightLength,
UErrorCode &errorCode) const {
// U_FAILURE(errorCode) checked by caller.
if(left == right && leftLength == rightLength) {
return UCOL_EQUAL;
}
// Identical-prefix test.
int32_t equalPrefixLength = 0;
if(leftLength < 0) {
uint8_t c;
while((c = left[equalPrefixLength]) == right[equalPrefixLength]) {
if(c == 0) { return UCOL_EQUAL; }
++equalPrefixLength;
}
} else {
for(;;) {
if(equalPrefixLength == leftLength) {
if(equalPrefixLength == rightLength) { return UCOL_EQUAL; }
break;
} else if(equalPrefixLength == rightLength ||
left[equalPrefixLength] != right[equalPrefixLength]) {
break;
}
++equalPrefixLength;
}
}
// Back up to the start of a partially-equal code point.
if(equalPrefixLength > 0 &&
((equalPrefixLength != leftLength && U8_IS_TRAIL(left[equalPrefixLength])) ||
(equalPrefixLength != rightLength && U8_IS_TRAIL(right[equalPrefixLength])))) {
while(--equalPrefixLength > 0 && U8_IS_TRAIL(left[equalPrefixLength])) {}
}
UBool numeric = settings->isNumeric();
if(equalPrefixLength > 0) {
UBool unsafe = FALSE;
if(equalPrefixLength != leftLength) {
int32_t i = equalPrefixLength;
UChar32 c;
U8_NEXT_OR_FFFD(left, i, leftLength, c);
unsafe = data->isUnsafeBackward(c, numeric);
}
if(!unsafe && equalPrefixLength != rightLength) {
int32_t i = equalPrefixLength;
UChar32 c;
U8_NEXT_OR_FFFD(right, i, rightLength, c);
unsafe = data->isUnsafeBackward(c, numeric);
}
if(unsafe) {
// Identical prefix: Back up to the start of a contraction or reordering sequence.
UChar32 c;
do {
U8_PREV_OR_FFFD(left, 0, equalPrefixLength, c);
} while(equalPrefixLength > 0 && data->isUnsafeBackward(c, numeric));
}
// See the notes in the UTF-16 version.
// Pass the actual start of each string into the CollationIterators,
// plus the equalPrefixLength position,
// so that prefix matches back into the equal prefix work.
}
int32_t result;
int32_t fastLatinOptions = settings->fastLatinOptions;
if(fastLatinOptions >= 0 &&
(equalPrefixLength == leftLength ||
left[equalPrefixLength] <= CollationFastLatin::LATIN_MAX_UTF8_LEAD) &&
(equalPrefixLength == rightLength ||
right[equalPrefixLength] <= CollationFastLatin::LATIN_MAX_UTF8_LEAD)) {
if(leftLength >= 0) {
result = CollationFastLatin::compareUTF8(data->fastLatinTable,
settings->fastLatinPrimaries,
fastLatinOptions,
left + equalPrefixLength,
leftLength - equalPrefixLength,
right + equalPrefixLength,
rightLength - equalPrefixLength);
} else {
result = CollationFastLatin::compareUTF8(data->fastLatinTable,
settings->fastLatinPrimaries,
fastLatinOptions,
left + equalPrefixLength, -1,
right + equalPrefixLength, -1);
}
} else {
result = CollationFastLatin::BAIL_OUT_RESULT;
}
if(result == CollationFastLatin::BAIL_OUT_RESULT) {
if(settings->dontCheckFCD()) {
UTF8CollationIterator leftIter(data, numeric, left, equalPrefixLength, leftLength);
UTF8CollationIterator rightIter(data, numeric, right, equalPrefixLength, rightLength);
result = CollationCompare::compareUpToQuaternary(leftIter, rightIter, *settings, errorCode);
} else {
FCDUTF8CollationIterator leftIter(data, numeric, left, equalPrefixLength, leftLength);
FCDUTF8CollationIterator rightIter(data, numeric, right, equalPrefixLength, rightLength);
result = CollationCompare::compareUpToQuaternary(leftIter, rightIter, *settings, errorCode);
}
}
if(result != UCOL_EQUAL || settings->getStrength() < UCOL_IDENTICAL || U_FAILURE(errorCode)) {
return (UCollationResult)result;
}
// Note: If NUL-terminated, we could get the actual limits from the iterators now.
// That would complicate the iterators a bit, NUL-terminated strings are only a C convenience,
// and the benefit seems unlikely to be measurable.
// Compare identical level.
const Normalizer2Impl &nfcImpl = data->nfcImpl;
left += equalPrefixLength;
right += equalPrefixLength;
if(leftLength > 0) {
leftLength -= equalPrefixLength;
rightLength -= equalPrefixLength;
}
if(settings->dontCheckFCD()) {
UTF8NFDIterator leftIter(left, leftLength);
UTF8NFDIterator rightIter(right, rightLength);
return compareNFDIter(nfcImpl, leftIter, rightIter);
} else {
FCDUTF8NFDIterator leftIter(data, left, leftLength);
FCDUTF8NFDIterator rightIter(data, right, rightLength);
return compareNFDIter(nfcImpl, leftIter, rightIter);
}
}
UCollationResult
RuleBasedCollator::compare(UCharIterator &left, UCharIterator &right,
UErrorCode &errorCode) const {
if(U_FAILURE(errorCode) || &left == &right) { return UCOL_EQUAL; }
UBool numeric = settings->isNumeric();
// Identical-prefix test.
int32_t equalPrefixLength = 0;
{
UChar32 leftUnit;
UChar32 rightUnit;
while((leftUnit = left.next(&left)) == (rightUnit = right.next(&right))) {
if(leftUnit < 0) { return UCOL_EQUAL; }
++equalPrefixLength;
}
// Back out the code units that differed, for the real collation comparison.
if(leftUnit >= 0) { left.previous(&left); }
if(rightUnit >= 0) { right.previous(&right); }
if(equalPrefixLength > 0) {
if((leftUnit >= 0 && data->isUnsafeBackward(leftUnit, numeric)) ||
(rightUnit >= 0 && data->isUnsafeBackward(rightUnit, numeric))) {
// Identical prefix: Back up to the start of a contraction or reordering sequence.
do {
--equalPrefixLength;
leftUnit = left.previous(&left);
right.previous(&right);
} while(equalPrefixLength > 0 && data->isUnsafeBackward(leftUnit, numeric));
}
// See the notes in the UTF-16 version.
}
}
UCollationResult result;
if(settings->dontCheckFCD()) {
UIterCollationIterator leftIter(data, numeric, left);
UIterCollationIterator rightIter(data, numeric, right);
result = CollationCompare::compareUpToQuaternary(leftIter, rightIter, *settings, errorCode);
} else {
FCDUIterCollationIterator leftIter(data, numeric, left, equalPrefixLength);
FCDUIterCollationIterator rightIter(data, numeric, right, equalPrefixLength);
result = CollationCompare::compareUpToQuaternary(leftIter, rightIter, *settings, errorCode);
}
if(result != UCOL_EQUAL || settings->getStrength() < UCOL_IDENTICAL || U_FAILURE(errorCode)) {
return result;
}
// Compare identical level.
left.move(&left, equalPrefixLength, UITER_ZERO);
right.move(&right, equalPrefixLength, UITER_ZERO);
const Normalizer2Impl &nfcImpl = data->nfcImpl;
if(settings->dontCheckFCD()) {
UIterNFDIterator leftIter(left);
UIterNFDIterator rightIter(right);
return compareNFDIter(nfcImpl, leftIter, rightIter);
} else {
FCDUIterNFDIterator leftIter(data, left, equalPrefixLength);
FCDUIterNFDIterator rightIter(data, right, equalPrefixLength);
return compareNFDIter(nfcImpl, leftIter, rightIter);
}
}
CollationKey &
RuleBasedCollator::getCollationKey(const UnicodeString &s, CollationKey &key,
UErrorCode &errorCode) const {
return getCollationKey(s.getBuffer(), s.length(), key, errorCode);
}
CollationKey &
RuleBasedCollator::getCollationKey(const UChar *s, int32_t length, CollationKey& key,
UErrorCode &errorCode) const {
if(U_FAILURE(errorCode)) {
return key.setToBogus();
}
if(s == NULL && length != 0) {
errorCode = U_ILLEGAL_ARGUMENT_ERROR;
return key.setToBogus();
}
key.reset(); // resets the "bogus" state
CollationKeyByteSink sink(key);
writeSortKey(s, length, sink, errorCode);
if(U_FAILURE(errorCode)) {
key.setToBogus();
} else if(key.isBogus()) {
errorCode = U_MEMORY_ALLOCATION_ERROR;
} else {
key.setLength(sink.NumberOfBytesAppended());
}
return key;
}
int32_t
RuleBasedCollator::getSortKey(const UnicodeString &s,
uint8_t *dest, int32_t capacity) const {
return getSortKey(s.getBuffer(), s.length(), dest, capacity);
}
int32_t
RuleBasedCollator::getSortKey(const UChar *s, int32_t length,
uint8_t *dest, int32_t capacity) const {
if((s == NULL && length != 0) || capacity < 0 || (dest == NULL && capacity > 0)) {
return 0;
}
uint8_t noDest[1] = { 0 };
if(dest == NULL) {
// Distinguish pure preflighting from an allocation error.
dest = noDest;
capacity = 0;
}
FixedSortKeyByteSink sink(reinterpret_cast<char *>(dest), capacity);
UErrorCode errorCode = U_ZERO_ERROR;
writeSortKey(s, length, sink, errorCode);
return U_SUCCESS(errorCode) ? sink.NumberOfBytesAppended() : 0;
}
void
RuleBasedCollator::writeSortKey(const UChar *s, int32_t length,
SortKeyByteSink &sink, UErrorCode &errorCode) const {
if(U_FAILURE(errorCode)) { return; }
const UChar *limit = (length >= 0) ? s + length : NULL;
UBool numeric = settings->isNumeric();
CollationKeys::LevelCallback callback;
if(settings->dontCheckFCD()) {
UTF16CollationIterator iter(data, numeric, s, s, limit);
CollationKeys::writeSortKeyUpToQuaternary(iter, data->compressibleBytes, *settings,
sink, Collation::PRIMARY_LEVEL,
callback, TRUE, errorCode);
} else {
FCDUTF16CollationIterator iter(data, numeric, s, s, limit);
CollationKeys::writeSortKeyUpToQuaternary(iter, data->compressibleBytes, *settings,
sink, Collation::PRIMARY_LEVEL,
callback, TRUE, errorCode);
}
if(settings->getStrength() == UCOL_IDENTICAL) {
writeIdenticalLevel(s, limit, sink, errorCode);
}
static const char terminator = 0; // TERMINATOR_BYTE
sink.Append(&terminator, 1);
}
void
RuleBasedCollator::writeIdenticalLevel(const UChar *s, const UChar *limit,
SortKeyByteSink &sink, UErrorCode &errorCode) const {
// NFD quick check
const UChar *nfdQCYesLimit = data->nfcImpl.decompose(s, limit, NULL, errorCode);
if(U_FAILURE(errorCode)) { return; }
sink.Append(Collation::LEVEL_SEPARATOR_BYTE);
UChar32 prev = 0;
if(nfdQCYesLimit != s) {
prev = u_writeIdenticalLevelRun(prev, s, (int32_t)(nfdQCYesLimit - s), sink);
}
// Is there non-NFD text?
int32_t destLengthEstimate;
if(limit != NULL) {
if(nfdQCYesLimit == limit) { return; }
destLengthEstimate = (int32_t)(limit - nfdQCYesLimit);
} else {
// s is NUL-terminated
if(*nfdQCYesLimit == 0) { return; }
destLengthEstimate = -1;
}
UnicodeString nfd;
data->nfcImpl.decompose(nfdQCYesLimit, limit, nfd, destLengthEstimate, errorCode);
u_writeIdenticalLevelRun(prev, nfd.getBuffer(), nfd.length(), sink);
}
namespace {
/**
* internalNextSortKeyPart() calls CollationKeys::writeSortKeyUpToQuaternary()
* with an instance of this callback class.
* When another level is about to be written, the callback
* records the level and the number of bytes that will be written until
* the sink (which is actually a FixedSortKeyByteSink) fills up.
*
* When internalNextSortKeyPart() is called again, it restarts with the last level
* and ignores as many bytes as were written previously for that level.
*/
class PartLevelCallback : public CollationKeys::LevelCallback {
public:
PartLevelCallback(const SortKeyByteSink &s)
: sink(s), level(Collation::PRIMARY_LEVEL) {
levelCapacity = sink.GetRemainingCapacity();
}
virtual ~PartLevelCallback() {}
virtual UBool needToWrite(Collation::Level l) {
if(!sink.Overflowed()) {
// Remember a level that will be at least partially written.
level = l;
levelCapacity = sink.GetRemainingCapacity();
return TRUE;
} else {
return FALSE;
}
}
Collation::Level getLevel() const { return level; }
int32_t getLevelCapacity() const { return levelCapacity; }
private:
const SortKeyByteSink &sink;
Collation::Level level;
int32_t levelCapacity;
};
} // namespace
int32_t
RuleBasedCollator::internalNextSortKeyPart(UCharIterator *iter, uint32_t state[2],
uint8_t *dest, int32_t count, UErrorCode &errorCode) const {
if(U_FAILURE(errorCode)) { return 0; }
if(iter == NULL || state == NULL || count < 0 || (count > 0 && dest == NULL)) {
errorCode = U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
if(count == 0) { return 0; }
FixedSortKeyByteSink sink(reinterpret_cast<char *>(dest), count);
sink.IgnoreBytes((int32_t)state[1]);
iter->move(iter, 0, UITER_START);
Collation::Level level = (Collation::Level)state[0];
if(level <= Collation::QUATERNARY_LEVEL) {
UBool numeric = settings->isNumeric();
PartLevelCallback callback(sink);
if(settings->dontCheckFCD()) {
UIterCollationIterator ci(data, numeric, *iter);
CollationKeys::writeSortKeyUpToQuaternary(ci, data->compressibleBytes, *settings,
sink, level, callback, FALSE, errorCode);
} else {
FCDUIterCollationIterator ci(data, numeric, *iter, 0);
CollationKeys::writeSortKeyUpToQuaternary(ci, data->compressibleBytes, *settings,
sink, level, callback, FALSE, errorCode);
}
if(U_FAILURE(errorCode)) { return 0; }
if(sink.NumberOfBytesAppended() > count) {
state[0] = (uint32_t)callback.getLevel();
state[1] = (uint32_t)callback.getLevelCapacity();
return count;
}
// All of the normal levels are done.
if(settings->getStrength() == UCOL_IDENTICAL) {
level = Collation::IDENTICAL_LEVEL;
iter->move(iter, 0, UITER_START);
}
// else fall through to setting ZERO_LEVEL
}
if(level == Collation::IDENTICAL_LEVEL) {
int32_t levelCapacity = sink.GetRemainingCapacity();
UnicodeString s;
for(;;) {
UChar32 c = iter->next(iter);
if(c < 0) { break; }
s.append((UChar)c);
}
const UChar *sArray = s.getBuffer();
writeIdenticalLevel(sArray, sArray + s.length(), sink, errorCode);
if(U_FAILURE(errorCode)) { return 0; }
if(sink.NumberOfBytesAppended() > count) {
state[0] = (uint32_t)level;
state[1] = (uint32_t)levelCapacity;
return count;
}
}
// ZERO_LEVEL: Fill the remainder of dest with 00 bytes.
state[0] = (uint32_t)Collation::ZERO_LEVEL;
state[1] = 0;
int32_t length = sink.NumberOfBytesAppended();
int32_t i = length;
while(i < count) { dest[i++] = 0; }
return length;
}
void
RuleBasedCollator::internalGetCEs(const UnicodeString &str, UVector64 &ces,
UErrorCode &errorCode) const {
if(U_FAILURE(errorCode)) { return; }
const UChar *s = str.getBuffer();
const UChar *limit = s + str.length();
UBool numeric = settings->isNumeric();
if(settings->dontCheckFCD()) {
UTF16CollationIterator iter(data, numeric, s, s, limit);
int64_t ce;
while((ce = iter.nextCE(errorCode)) != Collation::NO_CE) {
ces.addElement(ce, errorCode);
}
} else {
FCDUTF16CollationIterator iter(data, numeric, s, s, limit);
int64_t ce;
while((ce = iter.nextCE(errorCode)) != Collation::NO_CE) {
ces.addElement(ce, errorCode);
}
}
}
namespace {
void appendSubtag(CharString &s, char letter, const char *subtag, int32_t length,
UErrorCode &errorCode) {
if(U_FAILURE(errorCode) || length == 0) { return; }
if(!s.isEmpty()) {
s.append('_', errorCode);
}
s.append(letter, errorCode);
for(int32_t i = 0; i < length; ++i) {
s.append(uprv_toupper(subtag[i]), errorCode);
}
}
void appendAttribute(CharString &s, char letter, UColAttributeValue value,
UErrorCode &errorCode) {
if(U_FAILURE(errorCode)) { return; }
if(!s.isEmpty()) {
s.append('_', errorCode);
}
static const char *valueChars = "1234...........IXO..SN..LU......";
s.append(letter, errorCode);
s.append(valueChars[value], errorCode);
}
} // namespace
int32_t
RuleBasedCollator::internalGetShortDefinitionString(const char *locale,
char *buffer, int32_t capacity,
UErrorCode &errorCode) const {
if(U_FAILURE(errorCode)) { return 0; }
if(buffer == NULL ? capacity != 0 : capacity < 0) {
errorCode = U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
if(locale == NULL) {
locale = internalGetLocaleID(ULOC_VALID_LOCALE, errorCode);
}
char resultLocale[ULOC_FULLNAME_CAPACITY + 1];
int32_t length = ucol_getFunctionalEquivalent(resultLocale, ULOC_FULLNAME_CAPACITY,
"collation", locale,
NULL, &errorCode);
if(U_FAILURE(errorCode)) { return 0; }
if(length == 0) {
uprv_strcpy(resultLocale, "root");
} else {
resultLocale[length] = 0;
}
// Append items in alphabetic order of their short definition letters.
CharString result;
char subtag[ULOC_KEYWORD_AND_VALUES_CAPACITY];
if(attributeHasBeenSetExplicitly(UCOL_ALTERNATE_HANDLING)) {
appendAttribute(result, 'A', getAttribute(UCOL_ALTERNATE_HANDLING, errorCode), errorCode);
}
// ATTR_VARIABLE_TOP not supported because 'B' was broken.
// See ICU tickets #10372 and #10386.
if(attributeHasBeenSetExplicitly(UCOL_CASE_FIRST)) {
appendAttribute(result, 'C', getAttribute(UCOL_CASE_FIRST, errorCode), errorCode);
}
if(attributeHasBeenSetExplicitly(UCOL_NUMERIC_COLLATION)) {
appendAttribute(result, 'D', getAttribute(UCOL_NUMERIC_COLLATION, errorCode), errorCode);
}
if(attributeHasBeenSetExplicitly(UCOL_CASE_LEVEL)) {
appendAttribute(result, 'E', getAttribute(UCOL_CASE_LEVEL, errorCode), errorCode);
}
if(attributeHasBeenSetExplicitly(UCOL_FRENCH_COLLATION)) {
appendAttribute(result, 'F', getAttribute(UCOL_FRENCH_COLLATION, errorCode), errorCode);
}
// Note: UCOL_HIRAGANA_QUATERNARY_MODE is deprecated and never changes away from default.
length = uloc_getKeywordValue(resultLocale, "collation", subtag, UPRV_LENGTHOF(subtag), &errorCode);
appendSubtag(result, 'K', subtag, length, errorCode);
length = uloc_getLanguage(resultLocale, subtag, UPRV_LENGTHOF(subtag), &errorCode);
appendSubtag(result, 'L', subtag, length, errorCode);
if(attributeHasBeenSetExplicitly(UCOL_NORMALIZATION_MODE)) {
appendAttribute(result, 'N', getAttribute(UCOL_NORMALIZATION_MODE, errorCode), errorCode);
}
length = uloc_getCountry(resultLocale, subtag, UPRV_LENGTHOF(subtag), &errorCode);
appendSubtag(result, 'R', subtag, length, errorCode);
if(attributeHasBeenSetExplicitly(UCOL_STRENGTH)) {
appendAttribute(result, 'S', getAttribute(UCOL_STRENGTH, errorCode), errorCode);
}
length = uloc_getVariant(resultLocale, subtag, UPRV_LENGTHOF(subtag), &errorCode);
appendSubtag(result, 'V', subtag, length, errorCode);
length = uloc_getScript(resultLocale, subtag, UPRV_LENGTHOF(subtag), &errorCode);
appendSubtag(result, 'Z', subtag, length, errorCode);
if(U_FAILURE(errorCode)) { return 0; }
if(result.length() <= capacity) {
uprv_memcpy(buffer, result.data(), result.length());
}
return u_terminateChars(buffer, capacity, result.length(), &errorCode);
}
UBool
RuleBasedCollator::isUnsafe(UChar32 c) const {
return data->isUnsafeBackward(c, settings->isNumeric());
}
void
RuleBasedCollator::computeMaxExpansions(const CollationTailoring *t, UErrorCode &errorCode) {
t->maxExpansions = CollationElementIterator::computeMaxExpansions(t->data, errorCode);
}
UBool
RuleBasedCollator::initMaxExpansions(UErrorCode &errorCode) const {
umtx_initOnce(tailoring->maxExpansionsInitOnce, computeMaxExpansions, tailoring, errorCode);
return U_SUCCESS(errorCode);
}
CollationElementIterator *
RuleBasedCollator::createCollationElementIterator(const UnicodeString& source) const {
UErrorCode errorCode = U_ZERO_ERROR;
if(!initMaxExpansions(errorCode)) { return NULL; }
CollationElementIterator *cei = new CollationElementIterator(source, this, errorCode);
if(U_FAILURE(errorCode)) {
delete cei;
return NULL;
}
return cei;
}
CollationElementIterator *
RuleBasedCollator::createCollationElementIterator(const CharacterIterator& source) const {
UErrorCode errorCode = U_ZERO_ERROR;
if(!initMaxExpansions(errorCode)) { return NULL; }
CollationElementIterator *cei = new CollationElementIterator(source, this, errorCode);
if(U_FAILURE(errorCode)) {
delete cei;
return NULL;
}
return cei;
}
int32_t
RuleBasedCollator::getMaxExpansion(int32_t order) const {
UErrorCode errorCode = U_ZERO_ERROR;
(void)initMaxExpansions(errorCode);
return CollationElementIterator::getMaxExpansion(tailoring->maxExpansions, order);
}
U_NAMESPACE_END
#endif // !UCONFIG_NO_COLLATION