SkIcuBreakIteratorCache Class Reference

Public Member Functions
ICUBreakIterator	makeBreakIterator (SkUnicode::BreakType type, const char *bcp47)

Static Public Member Functions
static SkIcuBreakIteratorCache &	get ()

Detailed Description

Definition at line 149 of file SkUnicode_icu.cpp.

Member Function Documentation

get()

static SkIcuBreakIteratorCache & SkIcuBreakIteratorCache::get ( )

inlinestatic

Definition at line 227 of file SkUnicode_icu.cpp.

                                          {
        static SkIcuBreakIteratorCache instance;
        return instance;
    }

makeBreakIterator()

ICUBreakIterator SkIcuBreakIteratorCache::makeBreakIterator ( SkUnicode::BreakType  type, const char *  bcp47  )

inline

Definition at line 232 of file SkUnicode_icu.cpp.

                                                                                   {
        SkAutoMutexExclusive lock(fCacheMutex);
        UErrorCode status = U_ZERO_ERROR;
 
        // Get ICU locale for BCP47 langtag
        char localeIDStorage[ULOC_FULLNAME_CAPACITY];
        const char* localeID = nullptr;
        if (bcp47) {
            sk_uloc_forLanguageTag(bcp47, localeIDStorage, ULOC_FULLNAME_CAPACITY, nullptr, &status);
            if (U_FAILURE(status)) {
                SkDEBUGF("Break error could not get language tag: %s", sk_u_errorName(status));
            } else if (localeIDStorage[0]) {
                localeID = localeIDStorage;
            }
        }
        if (!localeID) {
            localeID = sk_uloc_getDefault();
        }
 
        auto make = [](const Request& request) -> UBreakIterator* {
            UErrorCode status = U_ZERO_ERROR;
            UBreakIterator* bi = sk_ubrk_open(convertType(request.fType),
                                              request.fIcuLocale.c_str(),
                                              nullptr, 0, &status);
            if (U_FAILURE(status)) {
                SkDEBUGF("Break error: %s", sk_u_errorName(status));
            }
            return bi;
        };
 
        auto clone = [](const UBreakIterator* existing) -> ICUBreakIterator {
            if (!existing) {
                return nullptr;
            }
 
            UErrorCode status = U_ZERO_ERROR;
            ICUBreakIterator clone(sk_ubrk_clone(existing, &status));
            if (U_FAILURE(status)) {
                SkDEBUGF("Break error: %s", sk_u_errorName(status));
            }
            return clone;
        };
 
        Request request(type, localeID);
 
        // See if this request is already in the cache
        const sk_sp<BreakIteratorRef>* ref = fRequestCache.find(request);
        if (ref) {
            // See if the breakIterator needs to be re-created
            if (!(*ref)->breakIterator) {
                (*ref)->breakIterator = make(request);
            }
            return clone((*ref)->breakIterator);
        }
 
        // This request was not in the cache, create an iterator.
        ICUBreakIterator newIter(make(request));
        if (!newIter) {
            return nullptr;
        }
 
        sk_sp<BreakIteratorRef> newRef;
 
        // Check if the new iterator is a duplicate
        // Android doesn't expose ubrk_getLocaleByType so there is no means of de-duplicating.
        // ubrk_getAvailable seems like it should work, but the implementation is just every locale.
        if (SkGetICULib()->f_ubrk_getLocaleByType) {
            const char* actualLocale = SkGetICULib()->f_ubrk_getLocaleByType(
                                           newIter.get(), ULOC_ACTUAL_LOCALE, &status);
            // Android doesn't expose ubrk_getLocaleByType so a wrapper may return an error.
            if (!U_FAILURE(status)) {
                if (!actualLocale) {
                    actualLocale = "";
                }
                // If the actual locale is the same as the requested locale we know there is no entry.
                if (strcmp(actualLocale, localeID) != 0) {
                    Request actualRequest(type, actualLocale);
                    const sk_sp<BreakIteratorRef>* actualRef = fRequestCache.find(actualRequest);
                    if (actualRef) {
                        if (!(*actualRef)->breakIterator) {
                            (*actualRef)->breakIterator = newIter.release();
                        }
                        actualRef = fRequestCache.set(request, *actualRef);
                        return clone((*actualRef)->breakIterator);
                    } else {
                        this->purgeIfNeeded();
                        newRef = sk_make_sp<BreakIteratorRef>(std::move(newIter));
                        fRequestCache.set(actualRequest, newRef);
                    }
                }
            }
        }
 
        if (!newRef) {
            this->purgeIfNeeded();
            newRef = sk_make_sp<BreakIteratorRef>(std::move(newIter));
        }
        fRequestCache.set(request, newRef);
 
        return clone(newRef->breakIterator);
    }

---

The documentation for this class was generated from the following file:

• third_party/skia/modules/skunicode/src/SkUnicode_icu.cpp