SkResourceCache::Key Struct Reference

#include <SkResourceCache.h>

Inheritance diagram for SkResourceCache::Key:

Public Member Functions
void	init (void *nameSpace, uint64_t sharedID, size_t dataSize)
size_t	size () const
void *	getNamespace () const
uint64_t	getSharedID () const
uint32_t	hash () const
bool	operator== (const Key &other) const

Detailed Description

Definition at line 32 of file SkResourceCache.h.

Member Function Documentation

getNamespace()

void * SkResourceCache::Key::getNamespace ( ) const

inline

Definition at line 46 of file SkResourceCache.h.

{ return fNamespace; }

getSharedID()

uint64_t SkResourceCache::Key::getSharedID ( ) const

inline

Definition at line 47 of file SkResourceCache.h.

{ return ((uint64_t)fSharedID_hi << 32) | fSharedID_lo; }

hash()

uint32_t SkResourceCache::Key::hash ( ) const

inline

Definition at line 50 of file SkResourceCache.h.

{ return fHash; }

init()

void SkResourceCache::Key::init	(	void *	nameSpace,
		uint64_t	sharedID,
		size_t	dataSize
	)

Key subclasses must call this after their own fields and data are initialized. All fields and data must be tightly packed.

Parameters

nameSpace	must be unique per Key subclass.
sharedID	== 0 means ignore this field, does not support group purging.
dataSize	is size of fields and data of the subclass, must be a multiple of 4.

Definition at line 55 of file SkResourceCache.cpp.

                                                                                 {
    SkASSERT(SkAlign4(dataSize) == dataSize);
 
    // fCount32 and fHash are not hashed
    static const int kUnhashedLocal32s = 2; // fCache32 + fHash
    static const int kSharedIDLocal32s = 2; // fSharedID_lo + fSharedID_hi
    static const int kHashedLocal32s = kSharedIDLocal32s + (sizeof(fNamespace) >> 2);
    static const int kLocal32s = kUnhashedLocal32s + kHashedLocal32s;
 
    static_assert(sizeof(Key) == (kLocal32s << 2), "unaccounted_key_locals");
    static_assert(sizeof(Key) == offsetof(Key, fNamespace) + sizeof(fNamespace),
                 "namespace_field_must_be_last");
 
    fCount32 = SkToS32(kLocal32s + (dataSize >> 2));
    fSharedID_lo = (uint32_t)(sharedID & 0xFFFFFFFF);
    fSharedID_hi = (uint32_t)(sharedID >> 32);
    fNamespace = nameSpace;
    // skip unhashed fields when computing the hash
    fHash = SkChecksum::Hash32(this->as32() + kUnhashedLocal32s,
                               (fCount32 - kUnhashedLocal32s) << 2);
}

operator==()

bool SkResourceCache::Key::operator== ( const Key &  other ) const

inline

Definition at line 52 of file SkResourceCache.h.

                                                {
            const uint32_t* a = this->as32();
            const uint32_t* b = other.as32();
            for (int i = 0; i < fCount32; ++i) {  // (This checks fCount == other.fCount first.)
                if (a[i] != b[i]) {
                    return false;
                }
            }
            return true;
        }

size()

size_t SkResourceCache::Key::size ( ) const

inline

Returns the size of this key.

Definition at line 42 of file SkResourceCache.h.

                            {
            return fCount32 << 2;
        }

---

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

• third_party/skia/src/core/SkResourceCache.h
• third_party/skia/src/core/SkResourceCache.cpp