|| || || || || || || ||

---

Cache.h

Go to the documentation of this file.

#ifndef Impala_Util_Cache_h
#define Impala_Util_Cache_h

#include <cstddef>
#include <deque>
#include <iostream>

namespace Impala
{
namespace Util
{


template<class IdxT, class ElemT>
class Cache
{
public:
    Cache(int maxCacheSize = 0, bool elemIsPointer = true)
    {
        mMaxCacheSize = maxCacheSize;
        mElemIsPointer = elemIsPointer;
    }

    virtual
    ~Cache()
    {
        Clear();
    }

    // should be called before elements are added to the cache
    void
    SetSize(int maxCacheSize)
    {
        mMaxCacheSize = maxCacheSize;
    }

    void
    AddElement(IdxT idx, ElemT elem)
    {
        if (mMaxCacheSize == 0)
            return;
        ILOG_DEBUG("add: pushing to front");
        mQueue.push_front(CacheElem<IdxT, ElemT>(idx, elem));
        if (mQueue.size() > mMaxCacheSize)
            PopBack();
    }

    bool
    GetElement(IdxT idx, ElemT& elem)
    {
        for (CacheIterator i=mQueue.begin() ; i!=mQueue.end() ; ++i)
        {
            if ((*i).mIdx == idx)
            {
                elem = (*i).mElem;
                mQueue.erase(i);
                AddElement(idx, elem);
                ILOG_DEBUG("get: found elem @ " << idx);
                return true;
            }
        }
        ILOG_DEBUG("get: elem @ " << idx << " not found");
        return false;
    }

    void
    RemoveElement(IdxT idx)
    {
        for (CacheIterator i=mQueue.begin() ; i!=mQueue.end() ; ++i)
        {
            if ((*i).mIdx == idx)
            {
                ElemT elem = (*i).mElem;
                if (mElemIsPointer && elem)
                    delete elem;
                mQueue.erase(i);
                return;
            }
        }
        ILOG_INFO("remove: elem @ " << idx << " not found");
    }

    void
    Dump(String name) const
    {
        std::ostringstream oss;
        oss << name << "Cache::Dump start" << std::endl;
        for (CacheConstIterator i=mQueue.begin() ; i!=mQueue.end() ; ++i)
        {
            oss << (*i).mIdx << " = " << (*i).mElem << std::endl;
        }
        oss << "Cache::Dump end" << std::endl;
        ILOG_INFO(oss.str());
    }

    void
    Clear()
    {
        if (mElemIsPointer)
        {
            while(!Empty())
                PopBack();
        }
        else
            mQueue.clear();
    }

    bool
    Empty()
    {
        return mQueue.empty();
    }
    
private:

    void
    PopBack()
    {
        if (mElemIsPointer)
        {
            ElemT e = mQueue.back().mElem;
            if (e) // allows for containment of null-pointers
            {
                delete e;
            }
        }
        mQueue.pop_back();
    }

    template<class CeIdxT, class CeElemT>
    class CacheElem
    {
    public:

        CacheElem()
        {
        }

        CacheElem(CeIdxT idx, CeElemT elem) : mIdx(idx), mElem(elem)
        {
        }

        CeIdxT  mIdx;
        CeElemT mElem;
    };

    typedef std::deque< CacheElem<IdxT, ElemT> > CacheQueue;
    typedef typename CacheQueue::iterator CacheIterator;
    typedef typename CacheQueue::const_iterator CacheConstIterator;

    Cache(const Cache&)
    {
    }

    Cache&
    operator=(const Cache&);

    CacheQueue mQueue;
    int        mMaxCacheSize;
    bool       mElemIsPointer;
    ILOG_VAR_DECL;
};

//template <class IdxT,class ElemT>
//log4cpp::Category& Cache<IdxT,ElemT>::sLog(log4cpp::Category::getInstance("Impala.Util.Cache"));
ILOG_VAR_INIT_TEMPL_2(Cache,IdxT,ElemT,Impala.Util);

} // namespace Util
} // namespace Impala

#endif

---