SkUnicode_libgrapheme Class Reference

Inheritance diagram for SkUnicode_libgrapheme:

Public Member Functions
	SkUnicode_libgrapheme ()
	~SkUnicode_libgrapheme () override=default
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 breakType) override
std::unique_ptr< SkBreakIterator >	makeBreakIterator (BreakType breakType) override
bool	getBidiRegions (const char utf8[], int utf8Units, TextDirection dir, std::vector< BidiRegion > *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, skia_private::TArray< SkUnicode::CodeUnitFlags, true > *results) override
bool	computeCodeUnitFlags (char16_t utf16[], int utf16Units, bool replaceTabs, skia_private::TArray< SkUnicode::CodeUnitFlags, true > *results) override
bool	getUtf8To16Mapping (const char utf8[], int utf8Units, std::unordered_map< Position, Position > *results)
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
SkString	toUpper (const SkString &str) override
SkString	toUpper (const SkString &str, const char *locale) override
void	reorderVisual (const BidiLevel runLevels[], int levelsCount, int32_t logicalFromVisual[]) override
Public Member Functions inherited from SkUnicodeHardCodedCharProperties
bool	isControl (SkUnichar utf8) override
bool	isWhitespace (SkUnichar utf8) override
bool	isSpace (SkUnichar utf8) override
bool	isTabulation (SkUnichar utf8) override
bool	isHardBreak (SkUnichar utf8) override
bool	isEmoji (SkUnichar utf8) override
bool	isEmojiComponent (SkUnichar utf8) override
bool	isEmojiModifierBase (SkUnichar utf8) override
bool	isEmojiModifier (SkUnichar utf8) override
bool	isRegionalIndicator (SkUnichar utf8) override
bool	isIdeographic (SkUnichar utf8) 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

Friends
class	SkBreakIterator_libgrapheme

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 30 of file SkUnicode_libgrapheme.cpp.

Constructor & Destructor Documentation

SkUnicode_libgrapheme()

SkUnicode_libgrapheme::SkUnicode_libgrapheme ( )

inline

Definition at line 32 of file SkUnicode_libgrapheme.cpp.

{ }

~SkUnicode_libgrapheme()

SkUnicode_libgrapheme::~SkUnicode_libgrapheme ( )

overridedefault

Member Function Documentation

computeCodeUnitFlags() [1/2]

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

inlineoverridevirtual

Implements SkUnicode.

Definition at line 60 of file SkUnicode_libgrapheme.cpp.

                                                                                                  {
        results->clear();
        results->push_back_n(utf8Units + 1, CodeUnitFlags::kNoCodeUnitFlag);
 
        size_t lineBreak = 0;
        (*results)[lineBreak] |= CodeUnitFlags::kSoftLineBreakBefore;
        while (lineBreak < utf8Units) {
            lineBreak += grapheme_next_line_break_utf8(utf8 + lineBreak, utf8Units - lineBreak);
            // Check if the previous code unit is a hard break.
            auto codePoint = utf8[lineBreak - 1];
            (*results)[lineBreak] |= this->isHardBreak(codePoint)
                                    ? CodeUnitFlags::kHardLineBreakBefore
                                    : CodeUnitFlags::kSoftLineBreakBefore;
        }
        (*results)[utf8Units] |= CodeUnitFlags::kSoftLineBreakBefore;
 
        size_t graphemeBreak = 0;
        (*results)[graphemeBreak] |= CodeUnitFlags::kGraphemeStart;
        while (graphemeBreak < utf8Units) {
            graphemeBreak += grapheme_next_character_break_utf8(utf8 + graphemeBreak, utf8Units - graphemeBreak);
            (*results)[graphemeBreak] |= 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;
                }
            }
        }
        return true;
    }

computeCodeUnitFlags() [2/2]

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

inlineoverridevirtual

Implements SkUnicode.

Definition at line 115 of file SkUnicode_libgrapheme.cpp.

                                                                                              {
        SkASSERT(false);
        return false;
    }

getBidiRegions()

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

inlineoverridevirtual

Implements SkUnicode.

Definition at line 45 of file SkUnicode_libgrapheme.cpp.

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

getSentences()

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

inlineoverridevirtual

Implements SkUnicode.

Definition at line 52 of file SkUnicode_libgrapheme.cpp.

                                                                      {
        SkDEBUGF("Method 'getSentences' is not implemented\n");
        return false;
    }

getUtf8To16Mapping()

bool SkUnicode_libgrapheme::getUtf8To16Mapping ( const char  utf8[], int  utf8Units, std::unordered_map< Position, Position > *  results  )

inline

Definition at line 121 of file SkUnicode_libgrapheme.cpp.

                                                                                                             {
        int utf16Units = 0;
        const char* ptr8 = utf8;
        const char* end8 = utf8 + utf8Units;
        while (ptr8 < end8) {
            results->emplace(ptr8 - utf8, utf16Units);
            SkUnichar uni = SkUTF::NextUTF8(&ptr8, end8);
            if (uni < 0) {
                return false;
            }
 
            uint16_t utf16[2];
            size_t count = SkUTF::ToUTF16(uni, utf16);
            if (count == 0) {
                return false;
            }
            utf16Units += count;
        }
        results->emplace(utf8Units, utf16Units);
        return true;
    }

getUtf8Words()

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

inlineoverridevirtual

Implements SkUnicode.

Definition at line 159 of file SkUnicode_libgrapheme.cpp.

                                                             {
        // Let's consider sort line breaks, whitespaces and CJK codepoints instead
        std::vector<CodeUnitFlags> breaks(utf8Units + 1, CodeUnitFlags::kNoCodeUnitFlag);
 
        size_t lineBreak = 0;
        breaks[lineBreak] = CodeUnitFlags::kSoftLineBreakBefore;
        while (lineBreak < utf8Units) {
            lineBreak += grapheme_next_line_break_utf8(utf8 + lineBreak, utf8Units - lineBreak);
            breaks[lineBreak] = CodeUnitFlags::kSoftLineBreakBefore;
        }
        breaks[lineBreak] = CodeUnitFlags::kSoftLineBreakBefore;
 
        const char* current = utf8;
        const char* end = utf8 + utf8Units;
        while (current < end) {
            auto index = current - utf8;
            SkUnichar unichar = SkUTF::NextUTF8(&current, end);
            if (this->isWhitespace(unichar)) {
                breaks[index] = CodeUnitFlags::kPartOfWhiteSpaceBreak;
            } else if (this->isIdeographic(unichar)) {
                breaks[index] = CodeUnitFlags::kIdeographic;
            }
        }
 
        bool whitespaces = false;
        for (size_t i = 0; i < breaks.size(); ++i) {
            auto b = breaks[i];
            if (b == CodeUnitFlags::kSoftLineBreakBefore) {
                results->emplace_back(i);
                whitespaces = false;
            } else if (b == CodeUnitFlags::kIdeographic) {
                results->emplace_back(i);
                whitespaces = false;
            } else if (b == CodeUnitFlags::kPartOfWhiteSpaceBreak) {
                if (!whitespaces) {
                    results->emplace_back(i);
                }
                whitespaces = true;
            } else {
                whitespaces = false;
            }
        }
 
        return true;
 
        /*
        size_t wordBreak = 0;
        while (wordBreak < utf8Units) {
            wordBreak += grapheme_next_word_break_utf8(utf8 + wordBreak, utf8Units - wordBreak);
            results->emplace_back(wordBreak);
        }
        return true;
        */
    }

getWords()

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

inlineoverridevirtual

Implements SkUnicode.

Definition at line 143 of file SkUnicode_libgrapheme.cpp.

                                                                                                               {
        std::unordered_map<Position, Position> mapping;
        if (!getUtf8To16Mapping(utf8, utf8Units, &mapping)) {
            return false;
        }
        size_t wordBreak = 0;
        while (wordBreak < utf8Units) {
            wordBreak += grapheme_next_word_break_utf8(utf8 + wordBreak, utf8Units - wordBreak);
            if (mapping.find(wordBreak) == mapping.end()) {
                return false;
            }
            results->emplace_back(mapping[wordBreak]);
        }
        return true;
    }

makeBidiIterator() [1/2]

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

overridevirtual

Implements SkUnicode.

Definition at line 286 of file SkUnicode_libgrapheme.cpp.

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

makeBidiIterator() [2/2]

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

overridevirtual

Implements SkUnicode.

Definition at line 282 of file SkUnicode_libgrapheme.cpp.

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

makeBreakIterator() [1/2]

std::unique_ptr< SkBreakIterator > SkUnicode_libgrapheme::makeBreakIterator ( BreakType  breakType )

overridevirtual

Implements SkUnicode.

Definition at line 295 of file SkUnicode_libgrapheme.cpp.

                                                                                           {
    return std::make_unique<SkBreakIterator_libgrapheme>(this);
}

makeBreakIterator() [2/2]

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

overridevirtual

Implements SkUnicode.

Definition at line 291 of file SkUnicode_libgrapheme.cpp.

                                                                        {
    return std::make_unique<SkBreakIterator_libgrapheme>(this);
}

reorderVisual()

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

inlineoverridevirtual

Implements SkUnicode.

Definition at line 227 of file SkUnicode_libgrapheme.cpp.

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

toUpper() [1/2]

SkString SkUnicode_libgrapheme::toUpper ( const SkString &  str )

inlineoverridevirtual

Implements SkUnicode.

Definition at line 217 of file SkUnicode_libgrapheme.cpp.

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

toUpper() [2/2]

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

inlineoverridevirtual

Implements SkUnicode.

Definition at line 221 of file SkUnicode_libgrapheme.cpp.

                                                                       {
        SkString res(" ", str.size());
        grapheme_to_uppercase_utf8(str.data(), str.size(), res.data(), res.size());
        return res;
    }

Friends And Related Symbol Documentation

SkBreakIterator_libgrapheme

friend class SkBreakIterator_libgrapheme

friend

Definition at line 233 of file SkUnicode_libgrapheme.cpp.

---

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

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