Cache.hh

//********************************************************************
//*** cache/Cache.hh
//*** Copyright (c) 2002 by Markus Winand <mws@fatalmind.com>
//*** $Id: Cache.hh,v 1.16 2008-01-20 13:33:13 mws Exp $
//********************************************************************

#ifndef CACHE_CACHE_HH
#define CACHE_CACHE_HH

#ifndef INCLUDED_GC_PTR_HH
#include "mm/gc_ptr.hh"
#endif

#ifndef TYPES_ARG_TRAITS_HH
#include "Types/arg_traits.hh"
#endif

#ifndef INCLUDED_THREAD_LOCK_HH
#include "Thread/Lock.hh"
#endif

#include <map>
#include <limits>
#include <time.h>

namespace fatalmind {

class LeastRecentlyUsedExpirationPolicy {
    public:
        LeastRecentlyUsedExpirationPolicy()
        : _lasthit(time(NULL))
        {
        };

        bool isValid() const throw() {
            return true;
        }
        int efficiency() const throw() {
            return _lasthit;
        }

        void hit() throw() {
            _lasthit = time(NULL);
        }
    private:
        time_t _lasthit;
};

template<typename K // key
    , typename V    // value
    , typename Ctor // ctor for value
    , typename E = LeastRecentlyUsedExpirationPolicy
    , class TM = DefaultThreadedModel
    , template <typename> class Allocator = std::allocator >
class CacheInterface {
    public:
        typedef gc_ptr<V, TM> value_t;
        virtual value_t get(typename arg_traits<K>::const_param key) = 0;
        virtual value_t get(
              typename arg_traits<K>::const_param key
            , typename arg_traits<Ctor>::const_param arg
        ) = 0;
        virtual value_t put(typename arg_traits<K>::const_param key, value_t val) = 0;
    
        virtual void invalidate(typename arg_traits<K>::const_param key) = 0;

        virtual ~CacheInterface() {
        }
};

template<typename K // key
    , typename V    // value
    , typename Ctor // ctor for value
    , typename E = LeastRecentlyUsedExpirationPolicy
    , class TM = DefaultThreadedModel
    , template <typename> class Allocator = std::allocator >
class Cache;

template<typename K, typename V, typename Ctor, typename E, class TM, template<typename> class Allocator>
std::ostream& operator<<(std::ostream&, const Cache<K, V, Ctor, E, TM, Allocator>& rho);

template<typename K // key
    , typename V    // value
    , typename Ctor // ctor for value
    , typename E
    , class TM
    , template <typename> class Allocator>
class Cache: public CacheInterface<K, V, Ctor, E, TM, Allocator> {
        typedef CacheInterface<K, V, Ctor, E, TM, Allocator> super;
    public:
        using super::value_t;
        explicit Cache(
              const unsigned int maxsize = std::numeric_limits<unsigned int>::max()
            , const unsigned int expirecnt = 0
        );
        virtual ~Cache() {};

        // miss if return.isNull() is true;
        virtual typename super::value_t get(typename arg_traits<K>::const_param key);
        virtual typename super::value_t get(
              typename arg_traits<K>::const_param key
            , typename arg_traits<Ctor>::const_param arg
        );
        virtual typename super::value_t put(
              typename arg_traits<K>::const_param key
            , typename super::value_t val
        );
        virtual void invalidate(
              typename arg_traits<K>::const_param key
        ); 
    protected:
        typedef typename TM::FastLock _lock_t;
        typedef std::pair<E, typename super::value_t> _entry_t;
        typedef std::pair<const K, _entry_t> _map_entry_t;
        typedef std::map<K, _entry_t, std::greater<K>, Allocator<_map_entry_t> > _map_t;

        inline void expire(typename _map_t::iterator hit);
        inline void _make_space_for_one();
        bool expire_invalid(typename _map_t::iterator hit);
        bool expire_invalid();
        inline bool full() const;

        _map_t _map;    
        mutable _lock_t _lk;
    
    private:
        const unsigned int _maxsize;
        const unsigned int _expirecnt;

    friend
        std::ostream& operator<< <>(std::ostream&, const Cache<K, V, Ctor, E, TM, Allocator>& rho);

    // hidden stuff
        Cache(const Cache&); // c-ctor
        Cache& operator=(const Cache&); // assignment
};


template<typename K // key
    , typename V    // value
    , typename Ctor // ctor for value
    , typename E = LeastRecentlyUsedExpirationPolicy
    , class TM = DefaultThreadedModel
    , template <typename> class Allocator = std::allocator >
class NopCache: public CacheInterface<K, V, Ctor, E, TM, Allocator> {
        typedef CacheInterface<K, V, Ctor, E, TM, Allocator> super;
    public:
        explicit NopCache(
              const unsigned int maxsize = 0
            , const unsigned int expirecnt = 0
        ) {
        }
        virtual ~NopCache() {};

        typedef typename super::value_t value_t;

        // miss if return.isNull() is true;
        virtual typename super::value_t get(typename arg_traits<K>::const_param key) {
            // always misses
            return value_t();
        }
        virtual typename super::value_t get(
              typename arg_traits<K>::const_param key
            , typename arg_traits<Ctor>::const_param arg
        ) {
            return value_t(arg());
        }

        virtual typename super::value_t put(
              typename arg_traits<K>::const_param key
            , typename super::value_t val
        ) {
            return val;
        }

        virtual void invalidate(
              typename arg_traits<K>::const_param key
        ) {
        }
    private:
    // hidden stuff
        NopCache(const NopCache&); // c-ctor
        NopCache& operator=(const NopCache&); // assignment
};

}// namespace fatalmind

#endif

---