SkCharToGlyphCache Class Reference

#include <SkCharToGlyphCache.h>

Public Member Functions
	SkCharToGlyphCache ()
	~SkCharToGlyphCache ()
int	count () const
void	reset ()
int	findGlyphIndex (SkUnichar c) const
void	insertCharAndGlyph (int index, SkUnichar, SkGlyphID)
void	addCharAndGlyph (SkUnichar unichar, SkGlyphID glyph)

Detailed Description

Definition at line 17 of file SkCharToGlyphCache.h.

Constructor & Destructor Documentation

SkCharToGlyphCache()

SkCharToGlyphCache::SkCharToGlyphCache

(

)

Definition at line 10 of file SkCharToGlyphCache.cpp.

                                       {
    this->reset();
}

~SkCharToGlyphCache()

SkCharToGlyphCache::~SkCharToGlyphCache

(

)

Definition at line 14 of file SkCharToGlyphCache.cpp.

{}

Member Function Documentation

addCharAndGlyph()

void SkCharToGlyphCache::addCharAndGlyph ( SkUnichar  unichar, SkGlyphID  glyph  )

inline

Definition at line 50 of file SkCharToGlyphCache.h.

                                                             {
        int index = this->findGlyphIndex(unichar);
        if (index >= 0) {
            SkASSERT(SkToU16(index) == glyph);
        } else {
            this->insertCharAndGlyph(~index, unichar, glyph);
        }
    }

count()

int SkCharToGlyphCache::count ( ) const

inline

Definition at line 23 of file SkCharToGlyphCache.h.

                      {
        return fK32.size();
    }

findGlyphIndex()

int SkCharToGlyphCache::findGlyphIndex

(

SkUnichar

c

)

const

Given a unichar, return its glyphID (if the return value is positive), else return ~index of where to insert the computed glyphID.

int result = cache.charToGlyph(unichar); if (result >= 0) { glyphID = result; } else { glyphID = compute_glyph_using_typeface(unichar); cache.insertCharAndGlyph(~result, unichar, glyphID); }

Definition at line 95 of file SkCharToGlyphCache.cpp.

                                                              {
    const int count = fK32.size();
    int index;
    if (count <= kSmallCountLimit) {
        index = find_simple(fK32.begin(), count, unichar);
    } else {
        index = find_with_slope(fK32.begin(), count, unichar, fDenom);
    }
    if (index >= 0) {
        return fV16[index];
    }
    return index;
}

insertCharAndGlyph()

void SkCharToGlyphCache::insertCharAndGlyph	(	int	index,
		SkUnichar	unichar,
		SkGlyphID	glyph
	)

Insert a new char/glyph pair into the cache at the specified index. See charToGlyph() for how to compute the bit-not of the index.

Definition at line 109 of file SkCharToGlyphCache.cpp.

                                                                                         {
    SkASSERT(fK32.size() == fV16.size());
    SkASSERT(index < fK32.size());
    SkASSERT(unichar < fK32[index]);
 
    *fK32.insert(index) = unichar;
    *fV16.insert(index) = glyph;
 
    // if we've changed the first [1] or last [count-2] entry, recompute our slope
    const int count = fK32.size();
    if (count >= kMinCountForSlope && (index == 1 || index == count - 2)) {
        SkASSERT(index >= 1 && index <= count - 2);
        fDenom = 1.0 / ((double)fK32[count - 2] - fK32[1]);
    }
 
#ifdef SK_DEBUG
    for (int i = 1; i < fK32.size(); ++i) {
        SkASSERT(fK32[i-1] < fK32[i]);
    }
#endif
}

reset()

void SkCharToGlyphCache::reset

(

)

Definition at line 16 of file SkCharToGlyphCache.cpp.

                               {
    fK32.reset();
    fV16.reset();
 
    // Add sentinels so we can always rely on these to stop linear searches (in either direction)
    // Neither is a legal unichar, so we don't care what glyphID we use.
    //
    *fK32.append() = 0x80000000;    *fV16.append() = 0;
    *fK32.append() = 0x7FFFFFFF;    *fV16.append() = 0;
 
    fDenom = 0;
}

---

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

• third_party/skia/src/utils/SkCharToGlyphCache.h
• third_party/skia/src/utils/SkCharToGlyphCache.cpp