SkLRUCache< K, V, HashK > Class Template Reference

#include <SkLRUCache.h>

Public Member Functions
	SkLRUCache (int maxCount)
	SkLRUCache ()=delete
	~SkLRUCache ()
	SkLRUCache (const SkLRUCache &)=delete
SkLRUCache &	operator= (const SkLRUCache &)=delete
V *	find (const K &key)
V *	insert (const K &key, V value)
V *	insert_or_update (const K &key, V value)
int	count () const
template<typename Fn >
void	foreach (Fn &&fn)
void	reset ()

Detailed Description

template<typename K, typename V, typename HashK = SkGoodHash>
class SkLRUCache< K, V, HashK >

A generic LRU cache.

Definition at line 19 of file SkLRUCache.h.

Constructor & Destructor Documentation

SkLRUCache() [1/3]

template<typename K , typename V , typename HashK = SkGoodHash>

SkLRUCache< K, V, HashK >::SkLRUCache ( int  maxCount )

inlineexplicit

Definition at line 33 of file SkLRUCache.h.

: fMaxCount(maxCount) {}

SkLRUCache() [2/3]

template<typename K , typename V , typename HashK = SkGoodHash>

SkLRUCache< K, V, HashK >::SkLRUCache ( )

delete

~SkLRUCache()

template<typename K , typename V , typename HashK = SkGoodHash>

SkLRUCache< K, V, HashK >::~SkLRUCache ( )

inline

Definition at line 36 of file SkLRUCache.h.

                  {
        Entry* node = fLRU.head();
        while (node) {
            fLRU.remove(node);
            delete node;
            node = fLRU.head();
        }
    }

SkLRUCache() [3/3]

template<typename K , typename V , typename HashK = SkGoodHash>

SkLRUCache< K, V, HashK >::SkLRUCache ( const SkLRUCache< K, V, HashK > &  )

delete

Member Function Documentation

count()

template<typename K , typename V , typename HashK = SkGoodHash>

int SkLRUCache< K, V, HashK >::count ( ) const

inline

Definition at line 83 of file SkLRUCache.h.

                      {
        return fMap.count();
    }

find()

template<typename K , typename V , typename HashK = SkGoodHash>

V * SkLRUCache< K, V, HashK >::find ( const K &  key )

inline

Definition at line 49 of file SkLRUCache.h.

                          {
        Entry** value = fMap.find(key);
        if (!value) {
            return nullptr;
        }
        Entry* entry = *value;
        if (entry != fLRU.head()) {
            fLRU.remove(entry);
            fLRU.addToHead(entry);
        } // else it's already at head position, don't need to do anything
        return &entry->fValue;
    }

foreach()

template<typename K , typename V , typename HashK = SkGoodHash>

template<typename Fn >

void SkLRUCache< K, V, HashK >::foreach ( Fn &&  fn )

inline

Definition at line 88 of file SkLRUCache.h.

                          {
        typename SkTInternalLList<Entry>::Iter iter;
        for (Entry* e = iter.init(fLRU, SkTInternalLList<Entry>::Iter::kHead_IterStart); e;
             e = iter.next()) {
            fn(&e->fKey, &e->fValue);
        }
    }

insert()

template<typename K , typename V , typename HashK = SkGoodHash>

V * SkLRUCache< K, V, HashK >::insert ( const K &  key, V  value  )

inline

Definition at line 62 of file SkLRUCache.h.

                                     {
        SkASSERT(!this->find(key));
 
        Entry* entry = new Entry(key, std::move(value));
        fMap.set(entry);
        fLRU.addToHead(entry);
        while (fMap.count() > fMaxCount) {
            this->remove(fLRU.tail()->fKey);
        }
        return &entry->fValue;
    }

insert_or_update()

template<typename K , typename V , typename HashK = SkGoodHash>

V * SkLRUCache< K, V, HashK >::insert_or_update ( const K &  key, V  value  )

inline

Definition at line 74 of file SkLRUCache.h.

                                               {
        if (V* found = this->find(key)) {
            *found = std::move(value);
            return found;
        } else {
            return this->insert(key, std::move(value));
        }
    }

operator=()

template<typename K , typename V , typename HashK = SkGoodHash>

SkLRUCache & SkLRUCache< K, V, HashK >::operator= ( const SkLRUCache< K, V, HashK > &  )

delete

reset()

template<typename K , typename V , typename HashK = SkGoodHash>

void SkLRUCache< K, V, HashK >::reset ( )

inline

Definition at line 96 of file SkLRUCache.h.

                 {
        fMap.reset();
        for (Entry* e = fLRU.head(); e; e = fLRU.head()) {
            fLRU.remove(e);
            delete e;
        }
    }

---

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

• third_party/skia/src/core/SkLRUCache.h