mirror of
https://github.com/unicode-org/icu.git
synced 2025-04-06 05:55:35 +00:00
ICU-2755 fixed RuleBasedCollator clone/cc operations to handle aliasing cases,
added additional tests for getLocale of registered collators, misc fixes to ICUService, StringSearch, ucollator to support changes. X-SVN-Rev: 11786
This commit is contained in:
Doug Felt
parent
f4d9e46ab0
commit
556c72cc54
13 changed files with 219 additions and 63 deletions
|
|
@ -427,6 +427,18 @@ SimpleLocaleKeyFactory::SimpleLocaleKeyFactory(UObject* objToAdopt,
|
|||
{
|
||||
}
|
||||
|
||||
SimpleLocaleKeyFactory::SimpleLocaleKeyFactory(UObject* objToAdopt,
|
||||
const Locale& locale,
|
||||
int32_t kind,
|
||||
int32_t coverage)
|
||||
: LocaleKeyFactory(coverage)
|
||||
, _obj(objToAdopt)
|
||||
, _id()
|
||||
, _kind(kind)
|
||||
{
|
||||
LocaleUtility::initNameFromLocale(locale, _id);
|
||||
}
|
||||
|
||||
SimpleLocaleKeyFactory::~SimpleLocaleKeyFactory()
|
||||
{
|
||||
delete _obj;
|
||||
|
|
@ -611,11 +623,15 @@ ICULocaleService::get(const Locale& locale, int32_t kind, Locale* actualReturn,
|
|||
return result;
|
||||
}
|
||||
|
||||
|
||||
URegistryKey
|
||||
ICULocaleService::registerInstance(UObject* objToAdopt, const UnicodeString
|
||||
& locale, UBool visible, UErrorCode& status)
|
||||
ICULocaleService::registerInstance(UObject* objToAdopt, const UnicodeString& locale,
|
||||
UBool visible, UErrorCode& status)
|
||||
{
|
||||
return ICUService::registerInstance(objToAdopt, locale, visible, status);
|
||||
Locale loc;
|
||||
LocaleUtility::initLocaleFromName(locale, loc);
|
||||
return registerInstance(objToAdopt, loc, LocaleKey::KIND_ANY,
|
||||
visible ? LocaleKeyFactory::VISIBLE : LocaleKeyFactory::INVISIBLE, status);
|
||||
}
|
||||
|
||||
URegistryKey
|
||||
|
|
@ -633,7 +649,7 @@ ICULocaleService::registerInstance(UObject* objToAdopt, const Locale& locale, in
|
|||
URegistryKey
|
||||
ICULocaleService::registerInstance(UObject* objToAdopt, const Locale& locale, int32_t kind, int32_t coverage, UErrorCode& status)
|
||||
{
|
||||
ICUServiceFactory * factory = new SimpleLocaleKeyFactory(objToAdopt, locale.getName(), kind, coverage);
|
||||
ICUServiceFactory * factory = new SimpleLocaleKeyFactory(objToAdopt, locale, kind, coverage);
|
||||
if (factory != NULL) {
|
||||
return registerFactory(factory, status);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -316,6 +316,11 @@ class U_COMMON_API SimpleLocaleKeyFactory : public LocaleKeyFactory {
|
|||
int32_t kind,
|
||||
int32_t coverage);
|
||||
|
||||
SimpleLocaleKeyFactory(UObject* objToAdopt,
|
||||
const Locale& locale,
|
||||
int32_t kind,
|
||||
int32_t coverage);
|
||||
|
||||
/**
|
||||
* Destructor.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -600,7 +600,7 @@ ICUService::get(const UnicodeString& descriptor, UnicodeString* actualReturn, UE
|
|||
UObject* result = NULL;
|
||||
ICUServiceKey* key = createKey(&descriptor, status);
|
||||
if (key) {
|
||||
result = getKey(*key, actualReturn, NULL, status);
|
||||
result = getKey(*key, actualReturn, status);
|
||||
delete key;
|
||||
}
|
||||
return result;
|
||||
|
|
@ -609,9 +609,12 @@ ICUService::get(const UnicodeString& descriptor, UnicodeString* actualReturn, UE
|
|||
UObject*
|
||||
ICUService::getKey(ICUServiceKey& key, UErrorCode& status) const
|
||||
{
|
||||
return getKey(key, NULL, NULL, status);
|
||||
return getKey(key, NULL, status);
|
||||
}
|
||||
|
||||
// this is a vector that subclasses of ICUService can override to further customize the result object
|
||||
// before returning it. All other public get functions should call this one.
|
||||
|
||||
UObject*
|
||||
ICUService::getKey(ICUServiceKey& key, UnicodeString* actualReturn, UErrorCode& status) const
|
||||
{
|
||||
|
|
@ -643,7 +646,8 @@ struct UVectorDeleter {
|
|||
UVectorDeleter() : _obj(NULL) {}
|
||||
~UVectorDeleter() { delete _obj; }
|
||||
};
|
||||
|
||||
|
||||
// called only by factories, treat as private
|
||||
UObject*
|
||||
ICUService::getKey(ICUServiceKey& key, UnicodeString* actualReturn, const ICUServiceFactory* factory, UErrorCode& status) const
|
||||
{
|
||||
|
|
|
|||
|
|
@ -660,19 +660,23 @@ class U_COMMON_API ICUService : public ICUNotifier {
|
|||
* object for the key, repeats the process with each fallback of
|
||||
* the key, until either a factory returns a service object, or the key
|
||||
* has no fallback. If no object is found, the result of handleDefault
|
||||
* is returned.</p>
|
||||
* is returned.</p>
|
||||
*
|
||||
* <p>Subclasses can override this method to further customize the
|
||||
* result before returning it.
|
||||
*
|
||||
* @param key the key.
|
||||
* @param actualReturn a pointer to a UnicodeString to hold the matched descriptor, or NULL.
|
||||
* @param status the error code status.
|
||||
* @return the service instance, or NULL.
|
||||
*/
|
||||
UObject* getKey(ICUServiceKey& key, UnicodeString* actualReturn, UErrorCode& status) const;
|
||||
virtual UObject* getKey(ICUServiceKey& key, UnicodeString* actualReturn, UErrorCode& status) const;
|
||||
|
||||
/**
|
||||
* <p>This version of getKey is only called by ICUServiceFactories within the scope
|
||||
* of a previous getKey call, to determine what previously-registered factories would
|
||||
* have returned. For details, see getKey(ICUServiceKey&, UErrorCode&).</p>
|
||||
* have returned. For details, see getKey(ICUServiceKey&, UErrorCode&). Subclasses
|
||||
* should not call it directly, but call through one of the other get functions.</p>
|
||||
*
|
||||
* @param key the key.
|
||||
* @param actualReturn a pointer to a UnicodeString to hold the matched descriptor, or NULL.
|
||||
|
|
|
|||
|
|
@ -115,6 +115,23 @@ class ICUCollatorService : public ICULocaleService {
|
|||
return Collator::makeInstance(loc, status);
|
||||
}
|
||||
|
||||
virtual UObject* getKey(ICUServiceKey& key, UnicodeString* actualReturn, UErrorCode& status) const {
|
||||
UnicodeString ar;
|
||||
if (actualReturn == NULL) {
|
||||
actualReturn = &ar;
|
||||
}
|
||||
Collator* result = (Collator*)ICULocaleService::getKey(key, actualReturn, status);
|
||||
if (result) {
|
||||
const LocaleKey& lkey = (const LocaleKey&)key;
|
||||
Locale canonicalLocale;
|
||||
Locale currentLocale;
|
||||
|
||||
result->setLocales(lkey.canonicalLocale(canonicalLocale),
|
||||
LocaleUtility::initLocaleFromName(*actualReturn, currentLocale));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
virtual UBool isDefault() const {
|
||||
return countFactories() == 1;
|
||||
}
|
||||
|
|
@ -427,16 +444,19 @@ CFactory::create(const ICUServiceKey& key, const ICUService* service, UErrorCode
|
|||
{
|
||||
if (handlesKey(key, status)) {
|
||||
const LocaleKey& lkey = (const LocaleKey&)key;
|
||||
Locale requestedLoc;
|
||||
lkey.canonicalLocale(requestedLoc);
|
||||
Locale validLoc;
|
||||
lkey.currentLocale(validLoc);
|
||||
return _delegate->createCollator(validLoc);
|
||||
/*
|
||||
Locale requestedLoc;
|
||||
lkey.canonicalLocale(requestedLoc);
|
||||
|
||||
Collator* result = _delegate->createCollator(validLoc);
|
||||
if (result) {
|
||||
result->setLocales(requestedLoc, validLoc);
|
||||
}
|
||||
return result;
|
||||
*/
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -42,6 +42,16 @@ StringSearch::StringSearch(const UnicodeString &pattern,
|
|||
uprv_free(m_search_);
|
||||
m_search_ = NULL;
|
||||
|
||||
// !!! dlf m_collator_ is an odd beast. basically it is an aliasing
|
||||
// wrapper around the internal collator and rules, which (here) are
|
||||
// owned by this stringsearch object. this means 1) it's destructor
|
||||
// _should not_ delete the ucollator or rules, and 2) changes made
|
||||
// to the exposed collator (setStrength etc) _should_ modify the
|
||||
// ucollator. thus the collator is not a copy-on-write alias, and it
|
||||
// needs to distinguish itself not merely from 'stand alone' colators
|
||||
// but also from copy-on-write ones. it needs additional state, which
|
||||
// setUCollator should set.
|
||||
|
||||
if (U_SUCCESS(status)) {
|
||||
int32_t length;
|
||||
const UChar *rules = ucol_getRules(m_strsrch_->collator, &length);
|
||||
|
|
|
|||
|
|
@ -73,11 +73,14 @@
|
|||
U_NAMESPACE_BEGIN
|
||||
|
||||
/**
|
||||
* Copy constructor
|
||||
* Copy constructor, aliasing, not write-through
|
||||
*/
|
||||
RuleBasedCollator::RuleBasedCollator(const RuleBasedCollator& that) :
|
||||
Collator(that), dataIsOwned(FALSE), ucollator(that.ucollator),
|
||||
urulestring(that.urulestring)
|
||||
RuleBasedCollator::RuleBasedCollator(const RuleBasedCollator& that)
|
||||
: Collator(that)
|
||||
, dataIsOwned(FALSE)
|
||||
, isWriteThroughAlias(FALSE)
|
||||
, ucollator(that.ucollator)
|
||||
, urulestring(that.urulestring)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
@ -124,19 +127,15 @@ RuleBasedCollator::RuleBasedCollator(const UnicodeString& rules,
|
|||
}
|
||||
|
||||
void
|
||||
RuleBasedCollator::construct(const UnicodeString& rules,
|
||||
UColAttributeValue collationStrength,
|
||||
UColAttributeValue decompositionMode,
|
||||
UErrorCode& status)
|
||||
RuleBasedCollator::setRuleStringFromCollator(UErrorCode& status)
|
||||
{
|
||||
ucollator = ucol_openRules(rules.getBuffer(), rules.length(),
|
||||
decompositionMode, collationStrength,
|
||||
NULL, &status);
|
||||
urulestring = NULL;
|
||||
if (U_SUCCESS(status))
|
||||
{
|
||||
int32_t length;
|
||||
const UChar *r = ucol_getRules(ucollator, &length);
|
||||
if (length > 0) {
|
||||
|
||||
if (length > 0) {
|
||||
// alias the rules string
|
||||
urulestring = new UnicodeString(TRUE, r, length);
|
||||
}
|
||||
|
|
@ -148,10 +147,26 @@ RuleBasedCollator::construct(const UnicodeString& rules,
|
|||
status = U_MEMORY_ALLOCATION_ERROR;
|
||||
return;
|
||||
}
|
||||
dataIsOwned = TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
// not aliasing, not write-through
|
||||
void
|
||||
RuleBasedCollator::construct(const UnicodeString& rules,
|
||||
UColAttributeValue collationStrength,
|
||||
UColAttributeValue decompositionMode,
|
||||
UErrorCode& status)
|
||||
{
|
||||
ucollator = ucol_openRules(rules.getBuffer(), rules.length(),
|
||||
decompositionMode, collationStrength,
|
||||
NULL, &status);
|
||||
|
||||
dataIsOwned = TRUE; // since we own a collator now, we need to get rid of it
|
||||
isWriteThroughAlias = FALSE;
|
||||
|
||||
setRuleStringFromCollator(status);
|
||||
}
|
||||
|
||||
/* RuleBasedCollator public destructor ----------------------------------- */
|
||||
|
||||
RuleBasedCollator::~RuleBasedCollator()
|
||||
|
|
@ -191,6 +206,7 @@ UBool RuleBasedCollator::operator==(const Collator& that) const
|
|||
*/
|
||||
}
|
||||
|
||||
// aliasing, not write-through
|
||||
RuleBasedCollator& RuleBasedCollator::operator=(const RuleBasedCollator& that)
|
||||
{
|
||||
if (this != &that)
|
||||
|
|
@ -203,12 +219,14 @@ RuleBasedCollator& RuleBasedCollator::operator=(const RuleBasedCollator& that)
|
|||
}
|
||||
|
||||
dataIsOwned = FALSE;
|
||||
isWriteThroughAlias = FALSE;
|
||||
ucollator = that.ucollator;
|
||||
urulestring = that.urulestring;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
// aliasing, not write-through
|
||||
Collator* RuleBasedCollator::clone() const
|
||||
{
|
||||
return new RuleBasedCollator(*this);
|
||||
|
|
@ -229,7 +247,7 @@ CollationElementIterator* RuleBasedCollator::createCollationElementIterator
|
|||
}
|
||||
|
||||
/**
|
||||
* Create a CollationElementIterator object that will iterator over the
|
||||
* Create a CollationElementIterator object that will iterate over the
|
||||
* elements in a string, using the collation rules defined in this
|
||||
* RuleBasedCollator
|
||||
*/
|
||||
|
|
@ -445,6 +463,7 @@ void RuleBasedCollator::setAttribute(UColAttribute attr,
|
|||
{
|
||||
if (U_FAILURE(status))
|
||||
return;
|
||||
checkOwned();
|
||||
ucol_setAttribute(ucollator, attr, value, &status);
|
||||
}
|
||||
|
||||
|
|
@ -457,15 +476,18 @@ UColAttributeValue RuleBasedCollator::getAttribute(UColAttribute attr,
|
|||
}
|
||||
|
||||
uint32_t RuleBasedCollator::setVariableTop(const UChar *varTop, int32_t len, UErrorCode &status) {
|
||||
return ucol_setVariableTop(ucollator, varTop, len, &status);
|
||||
checkOwned();
|
||||
return ucol_setVariableTop(ucollator, varTop, len, &status);
|
||||
}
|
||||
|
||||
uint32_t RuleBasedCollator::setVariableTop(const UnicodeString varTop, UErrorCode &status) {
|
||||
return ucol_setVariableTop(ucollator, varTop.getBuffer(), varTop.length(), &status);
|
||||
checkOwned();
|
||||
return ucol_setVariableTop(ucollator, varTop.getBuffer(), varTop.length(), &status);
|
||||
}
|
||||
|
||||
void RuleBasedCollator::setVariableTop(const uint32_t varTop, UErrorCode &status) {
|
||||
ucol_restoreVariableTop(ucollator, varTop, &status);
|
||||
checkOwned();
|
||||
ucol_restoreVariableTop(ucollator, varTop, &status);
|
||||
}
|
||||
|
||||
uint32_t RuleBasedCollator::getVariableTop(UErrorCode &status) const {
|
||||
|
|
@ -485,6 +507,8 @@ Collator* RuleBasedCollator::safeClone(void)
|
|||
UnicodeString *r = new UnicodeString(*urulestring);
|
||||
RuleBasedCollator *result = new RuleBasedCollator(ucol, r);
|
||||
result->dataIsOwned = TRUE;
|
||||
result->isWriteThroughAlias = FALSE;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
|
@ -512,6 +536,7 @@ Collator::ECollationStrength RuleBasedCollator::getStrength(void) const
|
|||
|
||||
void RuleBasedCollator::setStrength(ECollationStrength newStrength)
|
||||
{
|
||||
checkOwned();
|
||||
UErrorCode intStatus = U_ZERO_ERROR;
|
||||
UCollationStrength strength = getUCollationStrength(newStrength);
|
||||
ucol_setAttribute(ucollator, UCOL_STRENGTH, strength, &intStatus);
|
||||
|
|
@ -544,6 +569,7 @@ const Locale RuleBasedCollator::getLocale(ULocDataLocaleType type, UErrorCode &s
|
|||
|
||||
void
|
||||
RuleBasedCollator::setLocales(const Locale& requestedLocale, const Locale& validLocale) {
|
||||
checkOwned();
|
||||
size_t rlen = uprv_strlen(requestedLocale.getName());
|
||||
char* rloc = (char *)uprv_malloc((rlen+1)*sizeof(char));
|
||||
if (rloc) {
|
||||
|
|
@ -561,12 +587,14 @@ RuleBasedCollator::setLocales(const Locale& requestedLocale, const Locale& valid
|
|||
|
||||
// RuleBaseCollatorNew private constructor ----------------------------------
|
||||
|
||||
RuleBasedCollator::RuleBasedCollator() : dataIsOwned(FALSE), ucollator(0)
|
||||
RuleBasedCollator::RuleBasedCollator()
|
||||
: dataIsOwned(FALSE), isWriteThroughAlias(FALSE), ucollator(0)
|
||||
{
|
||||
}
|
||||
|
||||
RuleBasedCollator::RuleBasedCollator(UCollator *collator,
|
||||
UnicodeString *rule) : dataIsOwned(FALSE)
|
||||
UnicodeString *rule)
|
||||
: dataIsOwned(FALSE), isWriteThroughAlias(FALSE)
|
||||
{
|
||||
ucollator = collator;
|
||||
urulestring = rule;
|
||||
|
|
@ -631,11 +659,23 @@ RuleBasedCollator::RuleBasedCollator(const Locale& desiredLocale,
|
|||
return;
|
||||
}
|
||||
dataIsOwned = TRUE;
|
||||
isWriteThroughAlias = FALSE;
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
void
|
||||
RuleBasedCollator::checkOwned() {
|
||||
if (!(dataIsOwned || isWriteThroughAlias)) {
|
||||
UErrorCode status = U_ZERO_ERROR;
|
||||
ucollator = ucol_safeClone(ucollator, NULL, NULL, &status);
|
||||
setRuleStringFromCollator(status);
|
||||
dataIsOwned = TRUE;
|
||||
isWriteThroughAlias = FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
/* RuleBasedCollator private data members -------------------------------- */
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -410,7 +410,7 @@ clean:
|
|||
return NULL;
|
||||
}
|
||||
|
||||
result->validLocale = NULL;
|
||||
result->validLocale = NULL; // default is to use rb info
|
||||
|
||||
if(loc == NULL) {
|
||||
loc = ures_getLocale(result->rb, status);
|
||||
|
|
@ -419,7 +419,9 @@ clean:
|
|||
/* test for NULL */
|
||||
if (result->requestedLocale == NULL) {
|
||||
*status = U_MEMORY_ALLOCATION_ERROR;
|
||||
ures_close(collElem);
|
||||
ures_close(b); // ??? appears needed
|
||||
ures_close(collElem);
|
||||
ures_close(binary); // ??? appears needed
|
||||
return NULL;
|
||||
}
|
||||
uprv_strcpy(result->requestedLocale, loc);
|
||||
|
|
@ -434,12 +436,12 @@ ucol_setReqValidLocales(UCollator *coll, char *requestedLocaleToAdopt, char *val
|
|||
if (coll) {
|
||||
if (coll->validLocale) {
|
||||
uprv_free(coll->validLocale);
|
||||
coll->validLocale = validLocaleToAdopt;
|
||||
}
|
||||
}
|
||||
coll->validLocale = validLocaleToAdopt;
|
||||
if (coll->requestedLocale) { // should always have
|
||||
uprv_free(coll->requestedLocale);
|
||||
coll->requestedLocale = requestedLocaleToAdopt;
|
||||
}
|
||||
}
|
||||
coll->requestedLocale = requestedLocaleToAdopt;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -447,6 +449,15 @@ U_CAPI void U_EXPORT2
|
|||
ucol_close(UCollator *coll)
|
||||
{
|
||||
if(coll != NULL) {
|
||||
// these are always owned by each UCollator struct,
|
||||
// so we always free them
|
||||
if(coll->validLocale != NULL) {
|
||||
uprv_free(coll->validLocale);
|
||||
}
|
||||
if(coll->requestedLocale != NULL) {
|
||||
uprv_free(coll->requestedLocale);
|
||||
}
|
||||
|
||||
/* Here, it would be advisable to close: */
|
||||
/* - UData for UCA (unless we stuff it in the root resb */
|
||||
/* Again, do we need additional housekeeping... HMMM! */
|
||||
|
|
@ -474,12 +485,6 @@ ucol_close(UCollator *coll)
|
|||
if(coll->elements != NULL) {
|
||||
ures_close(coll->elements);
|
||||
}
|
||||
if(coll->validLocale != NULL) {
|
||||
uprv_free(coll->validLocale);
|
||||
}
|
||||
if(coll->requestedLocale != NULL) {
|
||||
uprv_free(coll->requestedLocale);
|
||||
}
|
||||
if(coll->latinOneCEs != NULL) {
|
||||
uprv_free(coll->latinOneCEs);
|
||||
}
|
||||
|
|
@ -1059,10 +1064,10 @@ ucol_initUCA(UErrorCode *status) {
|
|||
newUCA = ucol_initCollator((const UCATableHeader *)udata_getMemory(result), newUCA, status);
|
||||
if(U_SUCCESS(*status)){
|
||||
newUCA->rb = NULL;
|
||||
newUCA->elements = NULL;
|
||||
newUCA->validLocale = NULL;
|
||||
newUCA->requestedLocale = NULL;
|
||||
newUCA->hasRealData = FALSE; // real data lives in .dat file...
|
||||
newUCA->elements = NULL;
|
||||
newUCA->validLocale = NULL;
|
||||
newUCA->requestedLocale = NULL;
|
||||
newUCA->hasRealData = FALSE; // real data lives in .dat file...
|
||||
umtx_lock(NULL);
|
||||
if(UCA == NULL) {
|
||||
UCA = newUCA;
|
||||
|
|
@ -6596,7 +6601,7 @@ ucol_safeClone(const UCollator *coll, void *stackBuffer, int32_t * pBufferSize,
|
|||
if (status == NULL || U_FAILURE(*status)){
|
||||
return 0;
|
||||
}
|
||||
if (!pBufferSize || !coll){
|
||||
if ((stackBuffer && !pBufferSize) || !coll){
|
||||
*status = U_ILLEGAL_ARGUMENT_ERROR;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -6610,11 +6615,11 @@ ucol_safeClone(const UCollator *coll, void *stackBuffer, int32_t * pBufferSize,
|
|||
}
|
||||
stackBuffer = (void *)stackBufferChars;
|
||||
|
||||
if (*pBufferSize <= 0){ /* 'preflighting' request - set needed size into *pBufferSize */
|
||||
if (stackBuffer && *pBufferSize <= 0){ /* 'preflighting' request - set needed size into *pBufferSize */
|
||||
*pBufferSize = bufferSizeNeeded;
|
||||
return 0;
|
||||
}
|
||||
if (*pBufferSize < bufferSizeNeeded || stackBuffer == NULL) {
|
||||
if (!stackBuffer || *pBufferSize < bufferSizeNeeded) {
|
||||
/* allocate one here...*/
|
||||
int32_t length;
|
||||
const UChar * rules = ucol_getRules(coll, &length);
|
||||
|
|
@ -6633,6 +6638,8 @@ ucol_safeClone(const UCollator *coll, void *stackBuffer, int32_t * pBufferSize,
|
|||
localCollator = (UCollator *)stackBuffer;
|
||||
memcpy(localCollator, coll, sizeof(UCollator));
|
||||
localCollator->freeOnClose = FALSE;
|
||||
localCollator->requestedLocale = NULL; // zero copies of pointers
|
||||
localCollator->validLocale = NULL;
|
||||
}
|
||||
return localCollator;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -853,6 +853,12 @@ protected:
|
|||
// Collator protected methods -----------------------------------------
|
||||
|
||||
|
||||
/**
|
||||
* Used internally by registraton to define the requested and valid locales.
|
||||
* @param requestedLocale the requsted locale
|
||||
* @param validLocale the valid locale
|
||||
* @internal
|
||||
*/
|
||||
virtual void setLocales(const Locale& requestedLocale, const Locale& validLocale);
|
||||
|
||||
private:
|
||||
|
|
@ -863,6 +869,7 @@ private:
|
|||
Collator& operator=(const Collator& other);
|
||||
|
||||
friend class CFactory;
|
||||
friend class SimpleCFactory;
|
||||
friend class ICUCollatorFactory;
|
||||
friend class ICUCollatorService;
|
||||
static Collator* makeInstance(const Locale& desiredLocale,
|
||||
|
|
|
|||
|
|
@ -136,7 +136,7 @@ public:
|
|||
/**
|
||||
* Creating a <tt>StringSearch</tt> instance using the argument locale
|
||||
* language rule set. A collator will be created in the process, which
|
||||
* will be owned by this instance and will be deleted in during
|
||||
* will be owned by this instance and will be deleted during
|
||||
* destruction
|
||||
* @param pattern The text for which this object will search.
|
||||
* @param text The text in which to search for the pattern.
|
||||
|
|
@ -189,7 +189,7 @@ public:
|
|||
/**
|
||||
* Creating a <tt>StringSearch</tt> instance using the argument locale
|
||||
* language rule set. A collator will be created in the process, which
|
||||
* will be owned by this instance and will be deleted in during
|
||||
* will be owned by this instance and will be deleted during
|
||||
* destruction
|
||||
* <p>
|
||||
* Note: No parsing of the text within the <tt>CharacterIterator</tt>
|
||||
|
|
@ -338,11 +338,11 @@ public:
|
|||
virtual void setText(CharacterIterator &text, UErrorCode &status);
|
||||
|
||||
/**
|
||||
* Gets the collator used for the language rules.
|
||||
* Gets the collator used for the language rules.
|
||||
* <p>
|
||||
* Deleting the returned <tt>RuleBasedCollator</tt> before calling
|
||||
* the destructor would cause the string search to fail.
|
||||
* The destructor will delete the collator if this instance owns it
|
||||
* Caller may modify but <b>must not</b> delete the <tt>RuleBasedCollator</tt>!
|
||||
* Modifications to this collator will affect the original collator passed in to
|
||||
* the <tt>StringSearch>/tt> constructor or to setCollator, if any.
|
||||
* @return collator used for string search
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -650,6 +650,8 @@ private:
|
|||
|
||||
UBool dataIsOwned;
|
||||
|
||||
UBool isWriteThroughAlias;
|
||||
|
||||
/**
|
||||
* c struct for collation. All initialisation for it has to be done through
|
||||
* setUCollator().
|
||||
|
|
@ -752,9 +754,23 @@ public:
|
|||
*/
|
||||
const UCollator * getUCollator();
|
||||
|
||||
protected:
|
||||
/**
|
||||
* Used internally by registraton to define the requested and valid locales.
|
||||
* @param requestedLocale the requsted locale
|
||||
* @param validLocale the valid locale
|
||||
* @internal
|
||||
*/
|
||||
virtual void setLocales(const Locale& requestedLocale, const Locale& validLocale);
|
||||
|
||||
private:
|
||||
|
||||
// if not owned and not a write through alias, copy the ucollator
|
||||
void checkOwned(void);
|
||||
|
||||
// utility to init rule string used by checkOwned and construct
|
||||
void setRuleStringFromCollator(UErrorCode& status);
|
||||
|
||||
/**
|
||||
* Converts C's UCollationResult to EComparisonResult
|
||||
* @param result member of the enum UComparisonResult
|
||||
|
|
@ -804,6 +820,8 @@ inline void RuleBasedCollator::setUCollator(const char *locale,
|
|||
if (ucollator && dataIsOwned)
|
||||
ucol_close(ucollator);
|
||||
ucollator = ucol_open(locale, &status);
|
||||
dataIsOwned = TRUE;
|
||||
isWriteThroughAlias = FALSE;
|
||||
}
|
||||
|
||||
inline void RuleBasedCollator::setUCollator(const Locale &locale,
|
||||
|
|
@ -812,6 +830,7 @@ inline void RuleBasedCollator::setUCollator(const Locale &locale,
|
|||
setUCollator(locale.getName(), status);
|
||||
}
|
||||
|
||||
|
||||
inline void RuleBasedCollator::setUCollator(UCollator *collator,
|
||||
UnicodeString *rules)
|
||||
{
|
||||
|
|
@ -822,6 +841,7 @@ inline void RuleBasedCollator::setUCollator(UCollator *collator,
|
|||
ucollator = collator;
|
||||
urulestring = rules;
|
||||
dataIsOwned = FALSE;
|
||||
isWriteThroughAlias = TRUE;
|
||||
}
|
||||
|
||||
inline const UCollator * RuleBasedCollator::getUCollator()
|
||||
|
|
|
|||
|
|
@ -241,18 +241,18 @@ void IntlTestNumberFormatAPI::testAPI(/* char* par */)
|
|||
#define SRC_LOC Locale::getFrance()
|
||||
#define SWAP_LOC Locale::getUS()
|
||||
|
||||
class TestFactory : public SimpleNumberFormatFactory {
|
||||
class NFTestFactory : public SimpleNumberFormatFactory {
|
||||
NumberFormat* currencyStyle;
|
||||
|
||||
public:
|
||||
TestFactory()
|
||||
NFTestFactory()
|
||||
: SimpleNumberFormatFactory(SRC_LOC, TRUE)
|
||||
{
|
||||
UErrorCode status = U_ZERO_ERROR;
|
||||
currencyStyle = NumberFormat::createInstance(SWAP_LOC, status);
|
||||
}
|
||||
|
||||
virtual ~TestFactory()
|
||||
virtual ~NFTestFactory()
|
||||
{
|
||||
delete currencyStyle;
|
||||
}
|
||||
|
|
@ -279,7 +279,7 @@ private:
|
|||
static char gID;
|
||||
};
|
||||
|
||||
char TestFactory::gID = 0;
|
||||
char NFTestFactory::gID = 0;
|
||||
|
||||
void
|
||||
IntlTestNumberFormatAPI::testRegistration()
|
||||
|
|
@ -290,7 +290,7 @@ IntlTestNumberFormatAPI::testRegistration()
|
|||
NumberFormat* f0 = NumberFormat::createInstance(SWAP_LOC, status);
|
||||
NumberFormat* f1 = NumberFormat::createInstance(SRC_LOC, status);
|
||||
NumberFormat* f2 = NumberFormat::createCurrencyInstance(SRC_LOC, status);
|
||||
URegistryKey key = NumberFormat::registerFactory(new TestFactory(), status);
|
||||
URegistryKey key = NumberFormat::registerFactory(new NFTestFactory(), status);
|
||||
NumberFormat* f3 = NumberFormat::createCurrencyInstance(SRC_LOC, status);
|
||||
NumberFormat* f3a = NumberFormat::createCurrencyInstance(SRC_LOC, status);
|
||||
NumberFormat* f4 = NumberFormat::createInstance(SRC_LOC, status);
|
||||
|
|
|
|||
|
|
@ -17,6 +17,7 @@ void CollationServiceTest::TestRegister()
|
|||
// register a singleton
|
||||
const Locale& FR = Locale::getFrance();
|
||||
const Locale& US = Locale::getUS();
|
||||
const Locale US_FOO("en", "US", "FOO");
|
||||
|
||||
UErrorCode status = U_ZERO_ERROR;
|
||||
|
||||
|
|
@ -26,10 +27,32 @@ void CollationServiceTest::TestRegister()
|
|||
{ // try override en_US collator
|
||||
URegistryKey key = Collator::registerInstance(frcol, US, status);
|
||||
|
||||
Collator* ncol = Collator::createInstance(US, status);
|
||||
Collator* ncol = Collator::createInstance(US_FOO, status);
|
||||
if (*frcol != *ncol) {
|
||||
errln("register of french collator for en_US failed");
|
||||
errln("register of french collator for en_US failed on request for en_US_FOO");
|
||||
}
|
||||
// ensure original collator's params not touched
|
||||
Locale loc = frcol->getLocale(ULOC_REQUESTED_LOCALE, status);
|
||||
if (loc != FR) {
|
||||
errln((const UnicodeString&)"fr collator's requested locale changed to " + loc.getName());
|
||||
}
|
||||
loc = frcol->getLocale(ULOC_VALID_LOCALE, status);
|
||||
if (loc != FR) {
|
||||
errln((const UnicodeString&)"fr collator's valid locale changed to " + loc.getName());
|
||||
}
|
||||
|
||||
loc = ncol->getLocale(ULOC_REQUESTED_LOCALE, status);
|
||||
if (loc != US_FOO) {
|
||||
errln((const UnicodeString&)"requested locale for en_US_FOO is not en_US_FOO but " + loc.getName());
|
||||
}
|
||||
loc = ncol->getLocale(ULOC_VALID_LOCALE, status);
|
||||
if (loc != US) {
|
||||
errln((const UnicodeString&)"valid locale for en_US_FOO is not en_US but " + loc.getName());
|
||||
}
|
||||
loc = ncol->getLocale(ULOC_ACTUAL_LOCALE, status);
|
||||
if (loc != US) {
|
||||
errln((const UnicodeString&)"actual locale for en_US_FOO is not en_US but " + loc.getName());
|
||||
}
|
||||
delete ncol; ncol = NULL;
|
||||
|
||||
if (!Collator::unregister(key, status)) {
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue