| // © 2019 and later: Unicode, Inc. and others. |
| // License & terms of use: http://www.unicode.org/copyright.html |
| |
| // localematcher.cpp |
| // created: 2019may08 Markus W. Scherer |
| |
| #include "unicode/utypes.h" |
| #include "unicode/localebuilder.h" |
| #include "unicode/localematcher.h" |
| #include "unicode/locid.h" |
| #include "unicode/stringpiece.h" |
| #include "unicode/uloc.h" |
| #include "unicode/uobject.h" |
| #include "cstring.h" |
| #include "localeprioritylist.h" |
| #include "loclikelysubtags.h" |
| #include "locdistance.h" |
| #include "lsr.h" |
| #include "uassert.h" |
| #include "uhash.h" |
| #include "ustr_imp.h" |
| #include "uvector.h" |
| |
| #define UND_LSR LSR("und", "", "", LSR::EXPLICIT_LSR) |
| |
| /** |
| * Indicator for the lifetime of desired-locale objects passed into the LocaleMatcher. |
| * |
| * @draft ICU 65 |
| */ |
| enum ULocMatchLifetime { |
| /** |
| * Locale objects are temporary. |
| * The matcher will make a copy of a locale that will be used beyond one function call. |
| * |
| * @draft ICU 65 |
| */ |
| ULOCMATCH_TEMPORARY_LOCALES, |
| /** |
| * Locale objects are stored at least as long as the matcher is used. |
| * The matcher will keep only a pointer to a locale that will be used beyond one function call, |
| * avoiding a copy. |
| * |
| * @draft ICU 65 |
| */ |
| ULOCMATCH_STORED_LOCALES // TODO: permanent? cached? clone? |
| }; |
| #ifndef U_IN_DOXYGEN |
| typedef enum ULocMatchLifetime ULocMatchLifetime; |
| #endif |
| |
| U_NAMESPACE_BEGIN |
| |
| LocaleMatcher::Result::Result(LocaleMatcher::Result &&src) U_NOEXCEPT : |
| desiredLocale(src.desiredLocale), |
| supportedLocale(src.supportedLocale), |
| desiredIndex(src.desiredIndex), |
| supportedIndex(src.supportedIndex), |
| desiredIsOwned(src.desiredIsOwned) { |
| if (desiredIsOwned) { |
| src.desiredLocale = nullptr; |
| src.desiredIndex = -1; |
| src.desiredIsOwned = FALSE; |
| } |
| } |
| |
| LocaleMatcher::Result::~Result() { |
| if (desiredIsOwned) { |
| delete desiredLocale; |
| } |
| } |
| |
| LocaleMatcher::Result &LocaleMatcher::Result::operator=(LocaleMatcher::Result &&src) U_NOEXCEPT { |
| this->~Result(); |
| |
| desiredLocale = src.desiredLocale; |
| supportedLocale = src.supportedLocale; |
| desiredIndex = src.desiredIndex; |
| supportedIndex = src.supportedIndex; |
| desiredIsOwned = src.desiredIsOwned; |
| |
| if (desiredIsOwned) { |
| src.desiredLocale = nullptr; |
| src.desiredIndex = -1; |
| src.desiredIsOwned = FALSE; |
| } |
| return *this; |
| } |
| |
| Locale LocaleMatcher::Result::makeResolvedLocale(UErrorCode &errorCode) const { |
| if (U_FAILURE(errorCode) || supportedLocale == nullptr) { |
| return Locale::getRoot(); |
| } |
| const Locale *bestDesired = getDesiredLocale(); |
| if (bestDesired == nullptr || *supportedLocale == *bestDesired) { |
| return *supportedLocale; |
| } |
| LocaleBuilder b; |
| b.setLocale(*supportedLocale); |
| |
| // Copy the region from bestDesired, if there is one. |
| const char *region = bestDesired->getCountry(); |
| if (*region != 0) { |
| b.setRegion(region); |
| } |
| |
| // Copy the variants from bestDesired, if there are any. |
| // Note that this will override any supportedLocale variants. |
| // For example, "sco-ulster-fonipa" + "...-fonupa" => "sco-fonupa" (replacing ulster). |
| const char *variants = bestDesired->getVariant(); |
| if (*variants != 0) { |
| b.setVariant(variants); |
| } |
| |
| // Copy the extensions from bestDesired, if there are any. |
| // C++ note: The following note, copied from Java, may not be true, |
| // as long as C++ copies by legacy ICU keyword, not by extension singleton. |
| // Note that this will override any supportedLocale extensions. |
| // For example, "th-u-nu-latn-ca-buddhist" + "...-u-nu-native" => "th-u-nu-native" |
| // (replacing calendar). |
| b.copyExtensionsFrom(*bestDesired, errorCode); |
| return b.build(errorCode); |
| } |
| |
| LocaleMatcher::Builder::Builder(LocaleMatcher::Builder &&src) U_NOEXCEPT : |
| errorCode_(src.errorCode_), |
| supportedLocales_(src.supportedLocales_), |
| thresholdDistance_(src.thresholdDistance_), |
| demotion_(src.demotion_), |
| defaultLocale_(src.defaultLocale_), |
| withDefault_(src.withDefault_), |
| favor_(src.favor_), |
| direction_(src.direction_) { |
| src.supportedLocales_ = nullptr; |
| src.defaultLocale_ = nullptr; |
| } |
| |
| LocaleMatcher::Builder::~Builder() { |
| delete supportedLocales_; |
| delete defaultLocale_; |
| delete maxDistanceDesired_; |
| delete maxDistanceSupported_; |
| } |
| |
| LocaleMatcher::Builder &LocaleMatcher::Builder::operator=(LocaleMatcher::Builder &&src) U_NOEXCEPT { |
| this->~Builder(); |
| |
| errorCode_ = src.errorCode_; |
| supportedLocales_ = src.supportedLocales_; |
| thresholdDistance_ = src.thresholdDistance_; |
| demotion_ = src.demotion_; |
| defaultLocale_ = src.defaultLocale_; |
| withDefault_ = src.withDefault_, |
| favor_ = src.favor_; |
| direction_ = src.direction_; |
| |
| src.supportedLocales_ = nullptr; |
| src.defaultLocale_ = nullptr; |
| return *this; |
| } |
| |
| void LocaleMatcher::Builder::clearSupportedLocales() { |
| if (supportedLocales_ != nullptr) { |
| supportedLocales_->removeAllElements(); |
| } |
| } |
| |
| bool LocaleMatcher::Builder::ensureSupportedLocaleVector() { |
| if (U_FAILURE(errorCode_)) { return false; } |
| if (supportedLocales_ != nullptr) { return true; } |
| supportedLocales_ = new UVector(uprv_deleteUObject, nullptr, errorCode_); |
| if (U_FAILURE(errorCode_)) { return false; } |
| if (supportedLocales_ == nullptr) { |
| errorCode_ = U_MEMORY_ALLOCATION_ERROR; |
| return false; |
| } |
| return true; |
| } |
| |
| LocaleMatcher::Builder &LocaleMatcher::Builder::setSupportedLocalesFromListString( |
| StringPiece locales) { |
| LocalePriorityList list(locales, errorCode_); |
| if (U_FAILURE(errorCode_)) { return *this; } |
| clearSupportedLocales(); |
| if (!ensureSupportedLocaleVector()) { return *this; } |
| int32_t length = list.getLengthIncludingRemoved(); |
| for (int32_t i = 0; i < length; ++i) { |
| Locale *locale = list.orphanLocaleAt(i); |
| if (locale == nullptr) { continue; } |
| supportedLocales_->addElement(locale, errorCode_); |
| if (U_FAILURE(errorCode_)) { |
| delete locale; |
| break; |
| } |
| } |
| return *this; |
| } |
| |
| LocaleMatcher::Builder &LocaleMatcher::Builder::setSupportedLocales(Locale::Iterator &locales) { |
| if (U_FAILURE(errorCode_)) { return *this; } |
| clearSupportedLocales(); |
| if (!ensureSupportedLocaleVector()) { return *this; } |
| while (locales.hasNext()) { |
| const Locale &locale = locales.next(); |
| Locale *clone = locale.clone(); |
| if (clone == nullptr) { |
| errorCode_ = U_MEMORY_ALLOCATION_ERROR; |
| break; |
| } |
| supportedLocales_->addElement(clone, errorCode_); |
| if (U_FAILURE(errorCode_)) { |
| delete clone; |
| break; |
| } |
| } |
| return *this; |
| } |
| |
| LocaleMatcher::Builder &LocaleMatcher::Builder::addSupportedLocale(const Locale &locale) { |
| if (!ensureSupportedLocaleVector()) { return *this; } |
| Locale *clone = locale.clone(); |
| if (clone == nullptr) { |
| errorCode_ = U_MEMORY_ALLOCATION_ERROR; |
| return *this; |
| } |
| supportedLocales_->addElement(clone, errorCode_); |
| if (U_FAILURE(errorCode_)) { |
| delete clone; |
| } |
| return *this; |
| } |
| |
| LocaleMatcher::Builder &LocaleMatcher::Builder::setNoDefaultLocale() { |
| if (U_FAILURE(errorCode_)) { return *this; } |
| delete defaultLocale_; |
| defaultLocale_ = nullptr; |
| withDefault_ = false; |
| return *this; |
| } |
| |
| LocaleMatcher::Builder &LocaleMatcher::Builder::setDefaultLocale(const Locale *defaultLocale) { |
| if (U_FAILURE(errorCode_)) { return *this; } |
| Locale *clone = nullptr; |
| if (defaultLocale != nullptr) { |
| clone = defaultLocale->clone(); |
| if (clone == nullptr) { |
| errorCode_ = U_MEMORY_ALLOCATION_ERROR; |
| return *this; |
| } |
| } |
| delete defaultLocale_; |
| defaultLocale_ = clone; |
| withDefault_ = true; |
| return *this; |
| } |
| |
| LocaleMatcher::Builder &LocaleMatcher::Builder::setFavorSubtag(ULocMatchFavorSubtag subtag) { |
| if (U_FAILURE(errorCode_)) { return *this; } |
| favor_ = subtag; |
| return *this; |
| } |
| |
| LocaleMatcher::Builder &LocaleMatcher::Builder::setDemotionPerDesiredLocale(ULocMatchDemotion demotion) { |
| if (U_FAILURE(errorCode_)) { return *this; } |
| demotion_ = demotion; |
| return *this; |
| } |
| |
| LocaleMatcher::Builder &LocaleMatcher::Builder::setMaxDistance(const Locale &desired, |
| const Locale &supported) { |
| if (U_FAILURE(errorCode_)) { return *this; } |
| Locale *desiredClone = desired.clone(); |
| Locale *supportedClone = supported.clone(); |
| if (desiredClone == nullptr || supportedClone == nullptr) { |
| delete desiredClone; // in case only one could not be allocated |
| delete supportedClone; |
| errorCode_ = U_MEMORY_ALLOCATION_ERROR; |
| return *this; |
| } |
| delete maxDistanceDesired_; |
| delete maxDistanceSupported_; |
| maxDistanceDesired_ = desiredClone; |
| maxDistanceSupported_ = supportedClone; |
| return *this; |
| } |
| |
| #if 0 |
| /** |
| * <i>Internal only!</i> |
| * |
| * @param thresholdDistance the thresholdDistance to set, with -1 = default |
| * @return this Builder object |
| * @internal |
| * @deprecated This API is ICU internal only. |
| */ |
| @Deprecated |
| LocaleMatcher::Builder &LocaleMatcher::Builder::internalSetThresholdDistance(int32_t thresholdDistance) { |
| if (U_FAILURE(errorCode_)) { return *this; } |
| if (thresholdDistance > 100) { |
| thresholdDistance = 100; |
| } |
| thresholdDistance_ = thresholdDistance; |
| return *this; |
| } |
| #endif |
| |
| UBool LocaleMatcher::Builder::copyErrorTo(UErrorCode &outErrorCode) const { |
| if (U_FAILURE(outErrorCode)) { return TRUE; } |
| if (U_SUCCESS(errorCode_)) { return FALSE; } |
| outErrorCode = errorCode_; |
| return TRUE; |
| } |
| |
| LocaleMatcher LocaleMatcher::Builder::build(UErrorCode &errorCode) const { |
| if (U_SUCCESS(errorCode) && U_FAILURE(errorCode_)) { |
| errorCode = errorCode_; |
| } |
| return LocaleMatcher(*this, errorCode); |
| } |
| |
| namespace { |
| |
| LSR getMaximalLsrOrUnd(const XLikelySubtags &likelySubtags, const Locale &locale, |
| UErrorCode &errorCode) { |
| if (U_FAILURE(errorCode) || locale.isBogus() || *locale.getName() == 0 /* "und" */) { |
| return UND_LSR; |
| } else { |
| return likelySubtags.makeMaximizedLsrFrom(locale, errorCode); |
| } |
| } |
| |
| int32_t hashLSR(const UHashTok token) { |
| const LSR *lsr = static_cast<const LSR *>(token.pointer); |
| return lsr->hashCode; |
| } |
| |
| UBool compareLSRs(const UHashTok t1, const UHashTok t2) { |
| const LSR *lsr1 = static_cast<const LSR *>(t1.pointer); |
| const LSR *lsr2 = static_cast<const LSR *>(t2.pointer); |
| return *lsr1 == *lsr2; |
| } |
| |
| } // namespace |
| |
| int32_t LocaleMatcher::putIfAbsent(const LSR &lsr, int32_t i, int32_t suppLength, |
| UErrorCode &errorCode) { |
| if (U_FAILURE(errorCode)) { return suppLength; } |
| if (!uhash_containsKey(supportedLsrToIndex, &lsr)) { |
| uhash_putiAllowZero(supportedLsrToIndex, const_cast<LSR *>(&lsr), i, &errorCode); |
| if (U_SUCCESS(errorCode)) { |
| supportedLSRs[suppLength] = &lsr; |
| supportedIndexes[suppLength++] = i; |
| } |
| } |
| return suppLength; |
| } |
| |
| LocaleMatcher::LocaleMatcher(const Builder &builder, UErrorCode &errorCode) : |
| likelySubtags(*XLikelySubtags::getSingleton(errorCode)), |
| localeDistance(*LocaleDistance::getSingleton(errorCode)), |
| thresholdDistance(builder.thresholdDistance_), |
| demotionPerDesiredLocale(0), |
| favorSubtag(builder.favor_), |
| direction(builder.direction_), |
| supportedLocales(nullptr), lsrs(nullptr), supportedLocalesLength(0), |
| supportedLsrToIndex(nullptr), |
| supportedLSRs(nullptr), supportedIndexes(nullptr), supportedLSRsLength(0), |
| ownedDefaultLocale(nullptr), defaultLocale(nullptr) { |
| if (U_FAILURE(errorCode)) { return; } |
| const Locale *def = builder.defaultLocale_; |
| LSR builderDefaultLSR; |
| const LSR *defLSR = nullptr; |
| if (def != nullptr) { |
| ownedDefaultLocale = def->clone(); |
| if (ownedDefaultLocale == nullptr) { |
| errorCode = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| def = ownedDefaultLocale; |
| builderDefaultLSR = getMaximalLsrOrUnd(likelySubtags, *def, errorCode); |
| if (U_FAILURE(errorCode)) { return; } |
| defLSR = &builderDefaultLSR; |
| } |
| supportedLocalesLength = builder.supportedLocales_ != nullptr ? |
| builder.supportedLocales_->size() : 0; |
| if (supportedLocalesLength > 0) { |
| // Store the supported locales in input order, |
| // so that when different types are used (e.g., language tag strings) |
| // we can return those by parallel index. |
| supportedLocales = static_cast<const Locale **>( |
| uprv_malloc(supportedLocalesLength * sizeof(const Locale *))); |
| // Supported LRSs in input order. |
| // In C++, we store these permanently to simplify ownership management |
| // in the hash tables. Duplicate LSRs (if any) are unused overhead. |
| lsrs = new LSR[supportedLocalesLength]; |
| if (supportedLocales == nullptr || lsrs == nullptr) { |
| errorCode = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| // If the constructor fails partway, we need null pointers for destructibility. |
| uprv_memset(supportedLocales, 0, supportedLocalesLength * sizeof(const Locale *)); |
| for (int32_t i = 0; i < supportedLocalesLength; ++i) { |
| const Locale &locale = *static_cast<Locale *>(builder.supportedLocales_->elementAt(i)); |
| supportedLocales[i] = locale.clone(); |
| if (supportedLocales[i] == nullptr) { |
| errorCode = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| const Locale &supportedLocale = *supportedLocales[i]; |
| LSR &lsr = lsrs[i] = getMaximalLsrOrUnd(likelySubtags, supportedLocale, errorCode); |
| lsr.setHashCode(); |
| if (U_FAILURE(errorCode)) { return; } |
| } |
| |
| // We need an unordered map from LSR to first supported locale with that LSR, |
| // and an ordered list of (LSR, supported index) for |
| // the supported locales in the following order: |
| // 1. Default locale, if it is supported. |
| // 2. Priority locales (aka "paradigm locales") in builder order. |
| // 3. Remaining locales in builder order. |
| supportedLsrToIndex = uhash_openSize(hashLSR, compareLSRs, uhash_compareLong, |
| supportedLocalesLength, &errorCode); |
| if (U_FAILURE(errorCode)) { return; } |
| supportedLSRs = static_cast<const LSR **>( |
| uprv_malloc(supportedLocalesLength * sizeof(const LSR *))); |
| supportedIndexes = static_cast<int32_t *>( |
| uprv_malloc(supportedLocalesLength * sizeof(int32_t))); |
| if (supportedLSRs == nullptr || supportedIndexes == nullptr) { |
| errorCode = U_MEMORY_ALLOCATION_ERROR; |
| return; |
| } |
| int32_t suppLength = 0; |
| // Determine insertion order. |
| // Add locales immediately that are equivalent to the default. |
| MaybeStackArray<int8_t, 100> order(supportedLocalesLength, errorCode); |
| if (U_FAILURE(errorCode)) { return; } |
| int32_t numParadigms = 0; |
| for (int32_t i = 0; i < supportedLocalesLength; ++i) { |
| const Locale &locale = *supportedLocales[i]; |
| const LSR &lsr = lsrs[i]; |
| if (defLSR == nullptr && builder.withDefault_) { |
| // Implicit default locale = first supported locale, if not turned off. |
| U_ASSERT(i == 0); |
| def = &locale; |
| defLSR = &lsr; |
| order[i] = 1; |
| suppLength = putIfAbsent(lsr, 0, suppLength, errorCode); |
| } else if (defLSR != nullptr && lsr.isEquivalentTo(*defLSR)) { |
| order[i] = 1; |
| suppLength = putIfAbsent(lsr, i, suppLength, errorCode); |
| } else if (localeDistance.isParadigmLSR(lsr)) { |
| order[i] = 2; |
| ++numParadigms; |
| } else { |
| order[i] = 3; |
| } |
| if (U_FAILURE(errorCode)) { return; } |
| } |
| // Add supported paradigm locales. |
| int32_t paradigmLimit = suppLength + numParadigms; |
| for (int32_t i = 0; i < supportedLocalesLength && suppLength < paradigmLimit; ++i) { |
| if (order[i] == 2) { |
| suppLength = putIfAbsent(lsrs[i], i, suppLength, errorCode); |
| } |
| } |
| // Add remaining supported locales. |
| for (int32_t i = 0; i < supportedLocalesLength; ++i) { |
| if (order[i] == 3) { |
| suppLength = putIfAbsent(lsrs[i], i, suppLength, errorCode); |
| } |
| } |
| supportedLSRsLength = suppLength; |
| // If supportedLSRsLength < supportedLocalesLength then |
| // we waste as many array slots as there are duplicate supported LSRs, |
| // but the amount of wasted space is small as long as there are few duplicates. |
| } |
| |
| defaultLocale = def; |
| |
| if (builder.demotion_ == ULOCMATCH_DEMOTION_REGION) { |
| demotionPerDesiredLocale = localeDistance.getDefaultDemotionPerDesiredLocale(); |
| } |
| |
| if (thresholdDistance >= 0) { |
| // already copied |
| } else if (builder.maxDistanceDesired_ != nullptr) { |
| LSR suppLSR = getMaximalLsrOrUnd(likelySubtags, *builder.maxDistanceSupported_, errorCode); |
| const LSR *pSuppLSR = &suppLSR; |
| int32_t indexAndDistance = localeDistance.getBestIndexAndDistance( |
| getMaximalLsrOrUnd(likelySubtags, *builder.maxDistanceDesired_, errorCode), |
| &pSuppLSR, 1, |
| LocaleDistance::shiftDistance(100), favorSubtag, direction); |
| if (U_SUCCESS(errorCode)) { |
| // +1 for an exclusive threshold from an inclusive max. |
| thresholdDistance = LocaleDistance::getDistanceFloor(indexAndDistance) + 1; |
| } else { |
| thresholdDistance = 0; |
| } |
| } else { |
| thresholdDistance = localeDistance.getDefaultScriptDistance(); |
| } |
| } |
| |
| LocaleMatcher::LocaleMatcher(LocaleMatcher &&src) U_NOEXCEPT : |
| likelySubtags(src.likelySubtags), |
| localeDistance(src.localeDistance), |
| thresholdDistance(src.thresholdDistance), |
| demotionPerDesiredLocale(src.demotionPerDesiredLocale), |
| favorSubtag(src.favorSubtag), |
| direction(src.direction), |
| supportedLocales(src.supportedLocales), lsrs(src.lsrs), |
| supportedLocalesLength(src.supportedLocalesLength), |
| supportedLsrToIndex(src.supportedLsrToIndex), |
| supportedLSRs(src.supportedLSRs), |
| supportedIndexes(src.supportedIndexes), |
| supportedLSRsLength(src.supportedLSRsLength), |
| ownedDefaultLocale(src.ownedDefaultLocale), defaultLocale(src.defaultLocale) { |
| src.supportedLocales = nullptr; |
| src.lsrs = nullptr; |
| src.supportedLocalesLength = 0; |
| src.supportedLsrToIndex = nullptr; |
| src.supportedLSRs = nullptr; |
| src.supportedIndexes = nullptr; |
| src.supportedLSRsLength = 0; |
| src.ownedDefaultLocale = nullptr; |
| src.defaultLocale = nullptr; |
| } |
| |
| LocaleMatcher::~LocaleMatcher() { |
| for (int32_t i = 0; i < supportedLocalesLength; ++i) { |
| delete supportedLocales[i]; |
| } |
| uprv_free(supportedLocales); |
| delete[] lsrs; |
| uhash_close(supportedLsrToIndex); |
| uprv_free(supportedLSRs); |
| uprv_free(supportedIndexes); |
| delete ownedDefaultLocale; |
| } |
| |
| LocaleMatcher &LocaleMatcher::operator=(LocaleMatcher &&src) U_NOEXCEPT { |
| this->~LocaleMatcher(); |
| |
| thresholdDistance = src.thresholdDistance; |
| demotionPerDesiredLocale = src.demotionPerDesiredLocale; |
| favorSubtag = src.favorSubtag; |
| direction = src.direction; |
| supportedLocales = src.supportedLocales; |
| lsrs = src.lsrs; |
| supportedLocalesLength = src.supportedLocalesLength; |
| supportedLsrToIndex = src.supportedLsrToIndex; |
| supportedLSRs = src.supportedLSRs; |
| supportedIndexes = src.supportedIndexes; |
| supportedLSRsLength = src.supportedLSRsLength; |
| ownedDefaultLocale = src.ownedDefaultLocale; |
| defaultLocale = src.defaultLocale; |
| |
| src.supportedLocales = nullptr; |
| src.lsrs = nullptr; |
| src.supportedLocalesLength = 0; |
| src.supportedLsrToIndex = nullptr; |
| src.supportedLSRs = nullptr; |
| src.supportedIndexes = nullptr; |
| src.supportedLSRsLength = 0; |
| src.ownedDefaultLocale = nullptr; |
| src.defaultLocale = nullptr; |
| return *this; |
| } |
| |
| class LocaleLsrIterator { |
| public: |
| LocaleLsrIterator(const XLikelySubtags &likelySubtags, Locale::Iterator &locales, |
| ULocMatchLifetime lifetime) : |
| likelySubtags(likelySubtags), locales(locales), lifetime(lifetime) {} |
| |
| ~LocaleLsrIterator() { |
| if (lifetime == ULOCMATCH_TEMPORARY_LOCALES) { |
| delete remembered; |
| } |
| } |
| |
| bool hasNext() const { |
| return locales.hasNext(); |
| } |
| |
| LSR next(UErrorCode &errorCode) { |
| current = &locales.next(); |
| return getMaximalLsrOrUnd(likelySubtags, *current, errorCode); |
| } |
| |
| void rememberCurrent(int32_t desiredIndex, UErrorCode &errorCode) { |
| if (U_FAILURE(errorCode)) { return; } |
| bestDesiredIndex = desiredIndex; |
| if (lifetime == ULOCMATCH_STORED_LOCALES) { |
| remembered = current; |
| } else { |
| // ULOCMATCH_TEMPORARY_LOCALES |
| delete remembered; |
| remembered = new Locale(*current); |
| if (remembered == nullptr) { |
| errorCode = U_MEMORY_ALLOCATION_ERROR; |
| } |
| } |
| } |
| |
| const Locale *orphanRemembered() { |
| const Locale *rem = remembered; |
| remembered = nullptr; |
| return rem; |
| } |
| |
| int32_t getBestDesiredIndex() const { |
| return bestDesiredIndex; |
| } |
| |
| private: |
| const XLikelySubtags &likelySubtags; |
| Locale::Iterator &locales; |
| ULocMatchLifetime lifetime; |
| const Locale *current = nullptr, *remembered = nullptr; |
| int32_t bestDesiredIndex = -1; |
| }; |
| |
| const Locale *LocaleMatcher::getBestMatch(const Locale &desiredLocale, UErrorCode &errorCode) const { |
| if (U_FAILURE(errorCode)) { return nullptr; } |
| int32_t suppIndex = getBestSuppIndex( |
| getMaximalLsrOrUnd(likelySubtags, desiredLocale, errorCode), |
| nullptr, errorCode); |
| return U_SUCCESS(errorCode) && suppIndex >= 0 ? supportedLocales[suppIndex] : defaultLocale; |
| } |
| |
| const Locale *LocaleMatcher::getBestMatch(Locale::Iterator &desiredLocales, |
| UErrorCode &errorCode) const { |
| if (U_FAILURE(errorCode)) { return nullptr; } |
| if (!desiredLocales.hasNext()) { |
| return defaultLocale; |
| } |
| LocaleLsrIterator lsrIter(likelySubtags, desiredLocales, ULOCMATCH_TEMPORARY_LOCALES); |
| int32_t suppIndex = getBestSuppIndex(lsrIter.next(errorCode), &lsrIter, errorCode); |
| return U_SUCCESS(errorCode) && suppIndex >= 0 ? supportedLocales[suppIndex] : defaultLocale; |
| } |
| |
| const Locale *LocaleMatcher::getBestMatchForListString( |
| StringPiece desiredLocaleList, UErrorCode &errorCode) const { |
| LocalePriorityList list(desiredLocaleList, errorCode); |
| LocalePriorityList::Iterator iter = list.iterator(); |
| return getBestMatch(iter, errorCode); |
| } |
| |
| LocaleMatcher::Result LocaleMatcher::getBestMatchResult( |
| const Locale &desiredLocale, UErrorCode &errorCode) const { |
| if (U_FAILURE(errorCode)) { |
| return Result(nullptr, defaultLocale, -1, -1, FALSE); |
| } |
| int32_t suppIndex = getBestSuppIndex( |
| getMaximalLsrOrUnd(likelySubtags, desiredLocale, errorCode), |
| nullptr, errorCode); |
| if (U_FAILURE(errorCode) || suppIndex < 0) { |
| return Result(nullptr, defaultLocale, -1, -1, FALSE); |
| } else { |
| return Result(&desiredLocale, supportedLocales[suppIndex], 0, suppIndex, FALSE); |
| } |
| } |
| |
| LocaleMatcher::Result LocaleMatcher::getBestMatchResult( |
| Locale::Iterator &desiredLocales, UErrorCode &errorCode) const { |
| if (U_FAILURE(errorCode) || !desiredLocales.hasNext()) { |
| return Result(nullptr, defaultLocale, -1, -1, FALSE); |
| } |
| LocaleLsrIterator lsrIter(likelySubtags, desiredLocales, ULOCMATCH_TEMPORARY_LOCALES); |
| int32_t suppIndex = getBestSuppIndex(lsrIter.next(errorCode), &lsrIter, errorCode); |
| if (U_FAILURE(errorCode) || suppIndex < 0) { |
| return Result(nullptr, defaultLocale, -1, -1, FALSE); |
| } else { |
| return Result(lsrIter.orphanRemembered(), supportedLocales[suppIndex], |
| lsrIter.getBestDesiredIndex(), suppIndex, TRUE); |
| } |
| } |
| |
| int32_t LocaleMatcher::getBestSuppIndex(LSR desiredLSR, LocaleLsrIterator *remainingIter, |
| UErrorCode &errorCode) const { |
| if (U_FAILURE(errorCode)) { return -1; } |
| int32_t desiredIndex = 0; |
| int32_t bestSupportedLsrIndex = -1; |
| for (int32_t bestShiftedDistance = LocaleDistance::shiftDistance(thresholdDistance);;) { |
| // Quick check for exact maximized LSR. |
| if (supportedLsrToIndex != nullptr) { |
| desiredLSR.setHashCode(); |
| UBool found = false; |
| int32_t suppIndex = uhash_getiAndFound(supportedLsrToIndex, &desiredLSR, &found); |
| if (found) { |
| if (remainingIter != nullptr) { |
| remainingIter->rememberCurrent(desiredIndex, errorCode); |
| } |
| return suppIndex; |
| } |
| } |
| int32_t bestIndexAndDistance = localeDistance.getBestIndexAndDistance( |
| desiredLSR, supportedLSRs, supportedLSRsLength, |
| bestShiftedDistance, favorSubtag, direction); |
| if (bestIndexAndDistance >= 0) { |
| bestShiftedDistance = LocaleDistance::getShiftedDistance(bestIndexAndDistance); |
| if (remainingIter != nullptr) { |
| remainingIter->rememberCurrent(desiredIndex, errorCode); |
| if (U_FAILURE(errorCode)) { return -1; } |
| } |
| bestSupportedLsrIndex = LocaleDistance::getIndex(bestIndexAndDistance); |
| } |
| if ((bestShiftedDistance -= LocaleDistance::shiftDistance(demotionPerDesiredLocale)) <= 0) { |
| break; |
| } |
| if (remainingIter == nullptr || !remainingIter->hasNext()) { |
| break; |
| } |
| desiredLSR = remainingIter->next(errorCode); |
| if (U_FAILURE(errorCode)) { return -1; } |
| ++desiredIndex; |
| } |
| if (bestSupportedLsrIndex < 0) { |
| // no good match |
| return -1; |
| } |
| return supportedIndexes[bestSupportedLsrIndex]; |
| } |
| |
| UBool LocaleMatcher::isMatch(const Locale &desired, const Locale &supported, |
| UErrorCode &errorCode) const { |
| LSR suppLSR = getMaximalLsrOrUnd(likelySubtags, supported, errorCode); |
| if (U_FAILURE(errorCode)) { return 0; } |
| const LSR *pSuppLSR = &suppLSR; |
| int32_t indexAndDistance = localeDistance.getBestIndexAndDistance( |
| getMaximalLsrOrUnd(likelySubtags, desired, errorCode), |
| &pSuppLSR, 1, |
| LocaleDistance::shiftDistance(thresholdDistance), favorSubtag, direction); |
| return indexAndDistance >= 0; |
| } |
| |
| double LocaleMatcher::internalMatch(const Locale &desired, const Locale &supported, UErrorCode &errorCode) const { |
| // Returns the inverse of the distance: That is, 1-distance(desired, supported). |
| LSR suppLSR = getMaximalLsrOrUnd(likelySubtags, supported, errorCode); |
| if (U_FAILURE(errorCode)) { return 0; } |
| const LSR *pSuppLSR = &suppLSR; |
| int32_t indexAndDistance = localeDistance.getBestIndexAndDistance( |
| getMaximalLsrOrUnd(likelySubtags, desired, errorCode), |
| &pSuppLSR, 1, |
| LocaleDistance::shiftDistance(thresholdDistance), favorSubtag, direction); |
| double distance = LocaleDistance::getDistanceDouble(indexAndDistance); |
| return (100.0 - distance) / 100.0; |
| } |
| |
| U_NAMESPACE_END |
| |
| // uloc_acceptLanguage() --------------------------------------------------- *** |
| |
| U_NAMESPACE_USE |
| |
| namespace { |
| |
| class LocaleFromTag { |
| public: |
| LocaleFromTag() : locale(Locale::getRoot()) {} |
| const Locale &operator()(const char *tag) { return locale = Locale(tag); } |
| |
| private: |
| // Store the locale in the converter, rather than return a reference to a temporary, |
| // or a value which could go out of scope with the caller's reference to it. |
| Locale locale; |
| }; |
| |
| int32_t acceptLanguage(UEnumeration &supportedLocales, Locale::Iterator &desiredLocales, |
| char *dest, int32_t capacity, UAcceptResult *acceptResult, |
| UErrorCode &errorCode) { |
| if (U_FAILURE(errorCode)) { return 0; } |
| LocaleMatcher::Builder builder; |
| const char *locString; |
| while ((locString = uenum_next(&supportedLocales, nullptr, &errorCode)) != nullptr) { |
| Locale loc(locString); |
| if (loc.isBogus()) { |
| errorCode = U_ILLEGAL_ARGUMENT_ERROR; |
| return 0; |
| } |
| builder.addSupportedLocale(loc); |
| } |
| LocaleMatcher matcher = builder.build(errorCode); |
| LocaleMatcher::Result result = matcher.getBestMatchResult(desiredLocales, errorCode); |
| if (U_FAILURE(errorCode)) { return 0; } |
| if (result.getDesiredIndex() >= 0) { |
| if (acceptResult != nullptr) { |
| *acceptResult = *result.getDesiredLocale() == *result.getSupportedLocale() ? |
| ULOC_ACCEPT_VALID : ULOC_ACCEPT_FALLBACK; |
| } |
| const char *bestStr = result.getSupportedLocale()->getName(); |
| int32_t bestLength = (int32_t)uprv_strlen(bestStr); |
| if (bestLength <= capacity) { |
| uprv_memcpy(dest, bestStr, bestLength); |
| } |
| return u_terminateChars(dest, capacity, bestLength, &errorCode); |
| } else { |
| if (acceptResult != nullptr) { |
| *acceptResult = ULOC_ACCEPT_FAILED; |
| } |
| return u_terminateChars(dest, capacity, 0, &errorCode); |
| } |
| } |
| |
| } // namespace |
| |
| U_CAPI int32_t U_EXPORT2 |
| uloc_acceptLanguage(char *result, int32_t resultAvailable, |
| UAcceptResult *outResult, |
| const char **acceptList, int32_t acceptListCount, |
| UEnumeration *availableLocales, |
| UErrorCode *status) { |
| if (U_FAILURE(*status)) { return 0; } |
| if ((result == nullptr ? resultAvailable != 0 : resultAvailable < 0) || |
| (acceptList == nullptr ? acceptListCount != 0 : acceptListCount < 0) || |
| availableLocales == nullptr) { |
| *status = U_ILLEGAL_ARGUMENT_ERROR; |
| return 0; |
| } |
| LocaleFromTag converter; |
| Locale::ConvertingIterator<const char **, LocaleFromTag> desiredLocales( |
| acceptList, acceptList + acceptListCount, converter); |
| return acceptLanguage(*availableLocales, desiredLocales, |
| result, resultAvailable, outResult, *status); |
| } |
| |
| U_CAPI int32_t U_EXPORT2 |
| uloc_acceptLanguageFromHTTP(char *result, int32_t resultAvailable, |
| UAcceptResult *outResult, |
| const char *httpAcceptLanguage, |
| UEnumeration *availableLocales, |
| UErrorCode *status) { |
| if (U_FAILURE(*status)) { return 0; } |
| if ((result == nullptr ? resultAvailable != 0 : resultAvailable < 0) || |
| httpAcceptLanguage == nullptr || availableLocales == nullptr) { |
| *status = U_ILLEGAL_ARGUMENT_ERROR; |
| return 0; |
| } |
| LocalePriorityList list(httpAcceptLanguage, *status); |
| LocalePriorityList::Iterator desiredLocales = list.iterator(); |
| return acceptLanguage(*availableLocales, desiredLocales, |
| result, resultAvailable, outResult, *status); |
| } |
