MRU高速缓存使用彗星的STL

简介
我想你知道什么是MRU高速缓存;否则，你不会阅读。这是一个非常简单的使用唯一的STL的的实现。
要实现高速缓存，从这个模板类派生一个子类。作为执行者，你就必须实施两种方法:HandleNonExistingKeyFetch - 处理高速缓存未命中。在此方法中，你背后的高速缓存访​​问的实时数据来源，并返回值。HandleItemRelease - （可选）从缓存中删除项目时。
Cache类是两种类型，键和值（如哈希映射）的模板。值类型是资源的类型，键的类型是资源的地址（这是你如何获取资源）的类型。源代码

#include <list>

#include <map>



/**

 * MRU Cache

 *

 * contains up to a fixed size of "Most Recently Used" items,

 * where items are assiciated with keys.

 * when asked to fetch a value that is not

 * in the cache, HandleNonExistingKeyFetch is called.

 * when an item is removed from the cache, HandleItemRelease is called.

 * implementor of this cache must provide those methods.

 *

 */

template <typename key_type, typename value_type>

class MruCache

{

public:

    

    const int maxLength;



    MruCache(int iMaxLength) : maxLength(iMaxLength) { }



    inline value_type FetchItem(key_type key) { return __fetch_item(key); }



    virtual  MruCache() { Clear(); }



    /**

     * clear the cache.

     * for every item contained, HandleItemRelease is called.

     */

    virtual void Clear() { __clear(); }





protected:



    virtual void HandleItemRelease(key_type key, value_type value) { };



    virtual value_type HandleNonExistingKeyFetch(key_type key) = 0;



private:



    typedef struct _Entry

    {

        key_type key;

        value_type value;

    } Entry;



    typedef std::list<Entry> EntryList;

    EntryList listOfEntries;



    /**

     * for fast search in the cache.

     * this map contains pointers to iterators in EntryList.

     */

    typedef std::map<key_type, void*> ItrPtrMap;

    ItrPtrMap mapOfListIteratorPtr;



    value_type __fetch_item(key_type key)

    {

        Entry entry;

        EntryList::iterator* ptrItr = 

           (EntryList::iterator*) mapOfListIteratorPtr[key];

        if (!ptrItr)

        {

            if ( (int)listOfEntries.size() >= maxLength)

            {

                Entry lruEntry = listOfEntries.back();

                HandleItemRelease(lruEntry.key, lruEntry.value);

                listOfEntries.pop_back();

                delete mapOfListIteratorPtr[lruEntry.key];

                mapOfListIteratorPtr.erase(lruEntry.key);

            }



            entry.value = HandleNonExistingKeyFetch(key);

            entry.key = key;

            listOfEntries.push_front(entry);



            EntryList::iterator* ptrItr = new EntryList::iterator();

            *ptrItr = listOfEntries.begin();

            mapOfListIteratorPtr[key] = ptrItr;

        }

        else

        {

            entry = *(*ptrItr);

            listOfEntries.erase(*ptrItr);

            listOfEntries.push_front(entry);

            *ptrItr = listOfEntries.begin();

        }

        return entry.value;

    }



    virtual void __clear()

    {

        for (ItrPtrMap::iterator i=mapOfListIteratorPtr.begin(); 

             i!=mapOfListIteratorPtr.end(); i++)

        {

            void* ptrItr = i->second;

            EntryList::iterator* pItr = (EntryList::iterator*) ptrItr;

            HandleItemRelease( (*pItr)->key, (*pItr)->value );

            delete ptrItr;

        }

        listOfEntries.clear();

        mapOfListIteratorPtr.clear();

    }

};