SkUnicode_icu Class Reference

Inheritance diagram for SkUnicode_icu:

Public Member Functions
	~SkUnicode_icu () override
std::unique_ptr< SkBidiIterator >	makeBidiIterator (const uint16_t text[], int count, SkBidiIterator::Direction dir) override
std::unique_ptr< SkBidiIterator >	makeBidiIterator (const char text[], int count, SkBidiIterator::Direction dir) override
std::unique_ptr< SkBreakIterator >	makeBreakIterator (const char locale[], BreakType type) override
std::unique_ptr< SkBreakIterator >	makeBreakIterator (BreakType type) override
SkString	toUpper (const SkString &str) override
SkString	toUpper (const SkString &str, const char *locale) override
bool	getBidiRegions (const char utf8[], int utf8Units, TextDirection dir, std::vector< BidiRegion > *results) override
bool	getWords (const char utf8[], int utf8Units, const char *locale, std::vector< Position > *results) override
bool	getUtf8Words (const char utf8[], int utf8Units, const char *locale, std::vector< Position > *results) override
bool	getSentences (const char utf8[], int utf8Units, const char *locale, std::vector< SkUnicode::Position > *results) override
bool	computeCodeUnitFlags (char utf8[], int utf8Units, bool replaceTabs, TArray< SkUnicode::CodeUnitFlags, true > *results) override
bool	computeCodeUnitFlags (char16_t utf16[], int utf16Units, bool replaceTabs, TArray< SkUnicode::CodeUnitFlags, true > *results) override
void	reorderVisual (const BidiLevel runLevels[], int levelsCount, int32_t logicalFromVisual[]) override
Public Member Functions inherited from SkUnicode
	~SkUnicode () override=default
template<typename Callback >
void	forEachCodepoint (const char *utf8, int32_t utf8Units, Callback &&callback)
template<typename Callback >
void	forEachCodepoint (const char16_t *utf16, int32_t utf16Units, Callback &&callback)
template<typename Callback >
void	forEachBidiRegion (const uint16_t utf16[], int utf16Units, SkBidiIterator::Direction dir, Callback &&callback)
template<typename Callback >
void	forEachBreak (const char16_t utf16[], int utf16Units, SkUnicode::BreakType type, Callback &&callback)
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Private Member Functions
bool	isControl (SkUnichar utf8) override
bool	isWhitespace (SkUnichar utf8) override
bool	isSpace (SkUnichar utf8) override
bool	isHardBreak (SkUnichar utf8) override
bool	isEmoji (SkUnichar unichar) override
bool	isEmojiComponent (SkUnichar unichar) override
bool	isEmojiModifierBase (SkUnichar unichar) override
bool	isEmojiModifier (SkUnichar unichar) override
bool	isRegionalIndicator (SkUnichar unichar) override
bool	isIdeographic (SkUnichar unichar) override
bool	isTabulation (SkUnichar utf8) override

Additional Inherited Members
Public Types inherited from SkUnicode
enum	CodeUnitFlags {   kNoCodeUnitFlag = 0x00 , kPartOfWhiteSpaceBreak = 0x01 , kGraphemeStart = 0x02 , kSoftLineBreakBefore = 0x04 ,   kHardLineBreakBefore = 0x08 , kPartOfIntraWordBreak = 0x10 , kControl = 0x20 , kTabulation = 0x40 ,   kGlyphClusterStart = 0x80 , kIdeographic = 0x100 , kEmoji = 0x200 , kWordBreak = 0x400 ,   kSentenceBreak = 0x800 }
enum class	TextDirection { kLTR , kRTL }
enum class	LineBreakType { kSoftLineBreak = 0 , kHardLineBreak = 100 }
enum class	BreakType { kWords , kGraphemes , kLines , kSentences }
typedef size_t	Position
typedef uint8_t	BidiLevel
Static Public Member Functions inherited from SkUnicode
static bool	hasTabulationFlag (SkUnicode::CodeUnitFlags flags)
static bool	hasHardLineBreakFlag (SkUnicode::CodeUnitFlags flags)
static bool	hasSoftLineBreakFlag (SkUnicode::CodeUnitFlags flags)
static bool	hasGraphemeStartFlag (SkUnicode::CodeUnitFlags flags)
static bool	hasControlFlag (SkUnicode::CodeUnitFlags flags)
static bool	hasPartOfWhiteSpaceBreakFlag (SkUnicode::CodeUnitFlags flags)
static bool	extractBidi (const char utf8[], int utf8Units, TextDirection dir, std::vector< BidiRegion > *bidiRegions)
static SkString	convertUtf16ToUtf8 (const char16_t *utf16, int utf16Units)
static SkString	convertUtf16ToUtf8 (const std::u16string &utf16)
static std::u16string	convertUtf8ToUtf16 (const char *utf8, int utf8Units)
static std::u16string	convertUtf8ToUtf16 (const SkString &utf8)
template<typename Appender8 , typename Appender16 >
static bool	extractUtfConversionMapping (SkSpan< const char > utf8, Appender8 &&appender8, Appender16 &&appender16)

Detailed Description

Definition at line 336 of file SkUnicode_icu.cpp.

Constructor & Destructor Documentation

~SkUnicode_icu()

SkUnicode_icu::~SkUnicode_icu ( )

inlineoverride

Definition at line 473 of file SkUnicode_icu.cpp.

{ }

Member Function Documentation

computeCodeUnitFlags() [1/2]

bool SkUnicode_icu::computeCodeUnitFlags ( char  utf8[], int  utf8Units, bool  replaceTabs, TArray< SkUnicode::CodeUnitFlags, true > *  results  )

inlineoverridevirtual

Implements SkUnicode.

Definition at line 571 of file SkUnicode_icu.cpp.

                                                                                      {
        results->clear();
        results->push_back_n(utf8Units + 1, CodeUnitFlags::kNoCodeUnitFlag);
 
        SkUnicode_icu::extractPositions(utf8, utf8Units, BreakType::kLines, nullptr, // TODO: locale
                                        [&](int pos, int status) {
            (*results)[pos] |= status == UBRK_LINE_HARD
                                       ? CodeUnitFlags::kHardLineBreakBefore
                                       : CodeUnitFlags::kSoftLineBreakBefore;
        });
 
        SkUnicode_icu::extractPositions(utf8, utf8Units, BreakType::kGraphemes, nullptr, //TODO
                                        [&](int pos, int status) {
            (*results)[pos] |= CodeUnitFlags::kGraphemeStart;
        });
 
        const char* current = utf8;
        const char* end = utf8 + utf8Units;
        while (current < end) {
            auto before = current - utf8;
            SkUnichar unichar = SkUTF::NextUTF8(&current, end);
            if (unichar < 0) unichar = 0xFFFD;
            auto after = current - utf8;
            if (replaceTabs && this->isTabulation(unichar)) {
                results->at(before) |= SkUnicode::kTabulation;
                if (replaceTabs) {
                    unichar = ' ';
                    utf8[before] = ' ';
                }
            }
            for (auto i = before; i < after; ++i) {
                if (this->isSpace(unichar)) {
                    results->at(i) |= SkUnicode::kPartOfIntraWordBreak;
                }
                if (this->isWhitespace(unichar)) {
                    results->at(i) |= SkUnicode::kPartOfWhiteSpaceBreak;
                }
                if (this->isControl(unichar)) {
                    results->at(i) |= SkUnicode::kControl;
                }
                if (this->isIdeographic(unichar)) {
                    results->at(i) |= SkUnicode::kIdeographic;
                }
            }
        }
 
        return true;
    }

computeCodeUnitFlags() [2/2]

bool SkUnicode_icu::computeCodeUnitFlags ( char16_t  utf16[], int  utf16Units, bool  replaceTabs, TArray< SkUnicode::CodeUnitFlags, true > *  results  )

inlineoverridevirtual

Implements SkUnicode.

Definition at line 621 of file SkUnicode_icu.cpp.

                                                                                  {
        results->clear();
        results->push_back_n(utf16Units + 1, CodeUnitFlags::kNoCodeUnitFlag);
 
        // Get white spaces
        this->forEachCodepoint((char16_t*)&utf16[0], utf16Units,
           [this, results, replaceTabs, &utf16](SkUnichar unichar, int32_t start, int32_t end) {
                for (auto i = start; i < end; ++i) {
                    if (replaceTabs && this->isTabulation(unichar)) {
                        results->at(i) |= SkUnicode::kTabulation;
                    if (replaceTabs) {
                            unichar = ' ';
                            utf16[start] = ' ';
                        }
                    }
                    if (this->isSpace(unichar)) {
                        results->at(i) |= SkUnicode::kPartOfIntraWordBreak;
                    }
                    if (this->isWhitespace(unichar)) {
                        results->at(i) |= SkUnicode::kPartOfWhiteSpaceBreak;
                    }
                    if (this->isControl(unichar)) {
                        results->at(i) |= SkUnicode::kControl;
                    }
                }
           });
        // Get graphemes
        this->forEachBreak((char16_t*)&utf16[0],
                           utf16Units,
                           SkUnicode::BreakType::kGraphemes,
                           [results](SkBreakIterator::Position pos, SkBreakIterator::Status) {
                               (*results)[pos] |= CodeUnitFlags::kGraphemeStart;
                           });
        // Get line breaks
        this->forEachBreak(
                (char16_t*)&utf16[0],
                utf16Units,
                SkUnicode::BreakType::kLines,
                [results](SkBreakIterator::Position pos, SkBreakIterator::Status status) {
                    if (status ==
                        (SkBreakIterator::Status)SkUnicode::LineBreakType::kHardLineBreak) {
                        // Hard line breaks clears off all the other flags
                        // TODO: Treat \n as a formatting mark and do not pass it to SkShaper
                        (*results)[pos-1] = CodeUnitFlags::kHardLineBreakBefore;
                    } else {
                        (*results)[pos] |= CodeUnitFlags::kSoftLineBreakBefore;
                    }
                });
 
        return true;
    }

getBidiRegions()

bool SkUnicode_icu::getBidiRegions ( const char  utf8[], int  utf8Units, TextDirection  dir, std::vector< BidiRegion > *  results  )

inlineoverridevirtual

Implements SkUnicode.

Definition at line 521 of file SkUnicode_icu.cpp.

                                                                 {
        return fBidiFact->ExtractBidi(utf8, utf8Units, dir, results);
    }

getSentences()

bool SkUnicode_icu::getSentences ( const char  utf8[], int  utf8Units, const char *  locale, std::vector< SkUnicode::Position > *  results  )

inlineoverridevirtual

Implements SkUnicode.

Definition at line 559 of file SkUnicode_icu.cpp.

                                                                      {
        SkUnicode_icu::extractPositions(
                utf8, utf8Units, BreakType::kSentences, nullptr,
                [&](int pos, int status) {
                    results->emplace_back(pos);
                });
        return true;
    }

getUtf8Words()

bool SkUnicode_icu::getUtf8Words ( const char  utf8[], int  utf8Units, const char *  locale, std::vector< Position > *  results  )

inlineoverridevirtual

Implements SkUnicode.

Definition at line 536 of file SkUnicode_icu.cpp.

                                                             {
        // Convert to UTF16 since we want the results in utf16
        auto utf16 = convertUtf8ToUtf16(utf8, utf8Units);
        std::vector<Position> utf16Results;
        if (!SkUnicode_icu::extractWords(
                    (uint16_t*)utf16.c_str(), utf16.size(), locale, &utf16Results)) {
            return false;
        }
 
        std::vector<Position> mapping;
        SkSpan<const char> text(utf8, utf8Units);
        SkUnicode::extractUtfConversionMapping(
                text, [&](size_t index) { mapping.emplace_back(index); }, [&](size_t index) {});
 
        for (auto i16 : utf16Results) {
            results->emplace_back(mapping[i16]);
        }
        return true;
    }

getWords()

bool SkUnicode_icu::getWords ( const char  utf8[], int  utf8Units, const char *  locale, std::vector< Position > *  results  )

inlineoverridevirtual

Implements SkUnicode.

Definition at line 528 of file SkUnicode_icu.cpp.

                                                         {
 
        // Convert to UTF16 since we want the results in utf16
        auto utf16 = convertUtf8ToUtf16(utf8, utf8Units);
        return SkUnicode_icu::extractWords((uint16_t*)utf16.c_str(), utf16.size(), locale, results);
    }

isControl()

bool SkUnicode_icu::isControl ( SkUnichar  utf8 )

inlineoverrideprivatevirtual

Implements SkUnicode.

Definition at line 423 of file SkUnicode_icu.cpp.

                                            {
        return sk_u_iscntrl(utf8);
    }

isEmoji()

bool SkUnicode_icu::isEmoji ( SkUnichar  utf8 )

inlineoverrideprivatevirtual

Returns if a code point may start an emoji sequence. Returns true for '#', '*', and '0'-'9' since they may start an emoji sequence. To determine if a list of code points begins with an emoji sequence, use getEmojiSequence.

Implements SkUnicode.

Definition at line 439 of file SkUnicode_icu.cpp.

                                             {
        return sk_u_hasBinaryProperty(unichar, UCHAR_EMOJI);
    }

isEmojiComponent()

bool SkUnicode_icu::isEmojiComponent ( SkUnichar  unichar )

inlineoverrideprivatevirtual

Implements SkUnicode.

Definition at line 443 of file SkUnicode_icu.cpp.

                                                      {
        return sk_u_hasBinaryProperty(unichar, UCHAR_EMOJI_COMPONENT);
    }

isEmojiModifier()

bool SkUnicode_icu::isEmojiModifier ( SkUnichar  unichar )

inlineoverrideprivatevirtual

Implements SkUnicode.

Definition at line 451 of file SkUnicode_icu.cpp.

                                                     {
        return sk_u_hasBinaryProperty(unichar, UCHAR_EMOJI_MODIFIER);
    }

isEmojiModifierBase()

bool SkUnicode_icu::isEmojiModifierBase ( SkUnichar  unichar )

inlineoverrideprivatevirtual

Implements SkUnicode.

Definition at line 447 of file SkUnicode_icu.cpp.

                                                         {
        return sk_u_hasBinaryProperty(unichar, UCHAR_EMOJI_MODIFIER_BASE);
    }

isHardBreak()

bool SkUnicode_icu::isHardBreak ( SkUnichar  utf8 )

inlineoverrideprivatevirtual

Implements SkUnicode.

Definition at line 435 of file SkUnicode_icu.cpp.

                                              {
        return SkUnicode_icu::isHardLineBreak(utf8);
    }

isIdeographic()

bool SkUnicode_icu::isIdeographic ( SkUnichar  unichar )

inlineoverrideprivatevirtual

Implements SkUnicode.

Definition at line 459 of file SkUnicode_icu.cpp.

                                                   {
        return sk_u_hasBinaryProperty(unichar, UCHAR_IDEOGRAPHIC);
    }

isRegionalIndicator()

bool SkUnicode_icu::isRegionalIndicator ( SkUnichar  unichar )

inlineoverrideprivatevirtual

Implements SkUnicode.

Definition at line 455 of file SkUnicode_icu.cpp.

                                                         {
        return sk_u_hasBinaryProperty(unichar, UCHAR_REGIONAL_INDICATOR);
    }

isSpace()

bool SkUnicode_icu::isSpace ( SkUnichar  utf8 )

inlineoverrideprivatevirtual

Implements SkUnicode.

Definition at line 431 of file SkUnicode_icu.cpp.

                                          {
        return sk_u_isspace(utf8);
    }

isTabulation()

bool SkUnicode_icu::isTabulation ( SkUnichar  utf8 )

inlineoverrideprivatevirtual

Implements SkUnicode.

Definition at line 463 of file SkUnicode_icu.cpp.

                                               {
        return utf8 == '\t';
    }

isWhitespace()

bool SkUnicode_icu::isWhitespace ( SkUnichar  utf8 )

inlineoverrideprivatevirtual

Implements SkUnicode.

Definition at line 427 of file SkUnicode_icu.cpp.

                                               {
        return sk_u_isWhitespace(utf8);
    }

makeBidiIterator() [1/2]

std::unique_ptr< SkBidiIterator > SkUnicode_icu::makeBidiIterator ( const char  text[], int  count, SkBidiIterator::Direction  dir  )

inlineoverridevirtual

Implements SkUnicode.

Definition at line 478 of file SkUnicode_icu.cpp.

                                                                                           {
        return fBidiFact->MakeIterator(text, count, dir);
    }

makeBidiIterator() [2/2]

std::unique_ptr< SkBidiIterator > SkUnicode_icu::makeBidiIterator ( const uint16_t  text[], int  count, SkBidiIterator::Direction  dir  )

inlineoverridevirtual

Implements SkUnicode.

Definition at line 474 of file SkUnicode_icu.cpp.

                                                                                           {
        return fBidiFact->MakeIterator(text, count, dir);
    }

makeBreakIterator() [1/2]

std::unique_ptr< SkBreakIterator > SkUnicode_icu::makeBreakIterator ( BreakType  type )

inlineoverridevirtual

Implements SkUnicode.

Definition at line 491 of file SkUnicode_icu.cpp.

                                                                              {
        return makeBreakIterator(sk_uloc_getDefault(), type);
    }

makeBreakIterator() [2/2]

std::unique_ptr< SkBreakIterator > SkUnicode_icu::makeBreakIterator ( const char  locale[], BreakType  type  )

inlineoverridevirtual

Implements SkUnicode.

Definition at line 483 of file SkUnicode_icu.cpp.

                                                                                {
        ICUBreakIterator iterator = SkIcuBreakIteratorCache::get().makeBreakIterator(type, locale);
        if (!iterator) {
            return nullptr;
        }
        return std::unique_ptr<SkBreakIterator>(new SkBreakIterator_icu(std::move(iterator)));
    }

reorderVisual()

void SkUnicode_icu::reorderVisual ( const BidiLevel  runLevels[], int  levelsCount, int32_t  logicalFromVisual[]  )

inlineoverridevirtual

Implements SkUnicode.

Definition at line 674 of file SkUnicode_icu.cpp.

                                                             {
        fBidiFact->bidi_reorderVisual(runLevels, levelsCount, logicalFromVisual);
    }

toUpper() [1/2]

SkString SkUnicode_icu::toUpper ( const SkString &  str )

inlineoverridevirtual

Implements SkUnicode.

Definition at line 495 of file SkUnicode_icu.cpp.

                                                   {
        return this->toUpper(str, nullptr);
    }

toUpper() [2/2]

SkString SkUnicode_icu::toUpper ( const SkString &  str, const char *  locale  )

inlineoverridevirtual

Implements SkUnicode.

Definition at line 499 of file SkUnicode_icu.cpp.

                                                                       {
        // Convert to UTF16 since that's what ICU wants.
        auto str16 = SkUnicode::convertUtf8ToUtf16(str.c_str(), str.size());
 
        UErrorCode icu_err = U_ZERO_ERROR;
        const auto upper16len = sk_u_strToUpper(nullptr, 0, (UChar*)(str16.c_str()), str16.size(),
                                                locale, &icu_err);
        if (icu_err != U_BUFFER_OVERFLOW_ERROR || upper16len <= 0) {
            return SkString();
        }
 
        AutoSTArray<128, uint16_t> upper16(upper16len);
        icu_err = U_ZERO_ERROR;
        sk_u_strToUpper((UChar*)(upper16.get()), SkToS32(upper16.size()),
                        (UChar*)(str16.c_str()), str16.size(),
                        locale, &icu_err);
        SkASSERT(!U_FAILURE(icu_err));
 
        // ... and back to utf8 'cause that's what we want.
        return convertUtf16ToUtf8((char16_t*)upper16.get(), upper16.size());
    }

---

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

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