it_bus/timed_cache.h

#ifndef _CACHE_TIMED_CACHE_H_
#define _CACHE_TIMED_CACHE_H_

// @Copyright 2002 IONA Technologies, Plc. All Rights Reserved.
//
// A hashtable that enforces a maximum and a timeout.
//
// Maximum: if adding an element causes the size to grow beyond the
// maximum, the least recently cached values are removed. max==0
// means the cache is unbounded.
//
// Timeout: Each time the cache is searched or updated, all elements
// that have been in the cache for longer than the timeout are removed.
// The timeout is calculated from the time the value was cached,
// not from the last time it was accessed. timeout == 0 disables timeout.
//
// IMPORTANT NOTE: You must use the cache_insert and cache_find functions
// *not* the hashtable insert and find functions in order for the
// cache to work.

#include <it_dsa/hash_map.h>
#include <it_dsa/list.h>
#include <it_dsa/types.h>
#include <it_oss/time.h>

template<class Key, class Data, class HashFn, class Equal>
class IT_TimedCache 
{
public:
    IT_TimedCache(size_t max=0, size_t timeout=0);
    ~IT_TimedCache();
    
    IT_Bool insert(const Key& key, Data& data);

    Data* find(const Key& key);
    const Data* find(const Key& key) const;

    size_t size() const;

    size_t max() const;
    void max(size_t count);

    unsigned long timeout() const;
    void timeout(unsigned long milliseconds);

private:
    typedef IT_HashMap<Key, Data, HashFn, Equal> HashMap;
    typedef IT_TYPENAME HashMap::iterator MapIterator;
    typedef IT_Pair<MapIterator, IT_Time> ItemTime;
    typedef IT_List<ItemTime> Queue;

    void enforce_max();
    void enforce_timeout();
    void enforce();             // Both
    IT_Bool item_is_stale(IT_TYPENAME Queue::iterator item);

    HashMap m_map;
    Queue   m_queue;
    size_t  m_max;
    size_t  m_timeout;
    IT_Long m_timeout_secs;
    IT_Long m_timeout_msecs;

    // Not defined prevent accidental use.
    IT_TimedCache(const IT_TimedCache&);
    IT_Bool operator == (const IT_TimedCache&);
};


template<class Key, class Data, class HashFn, class Equal>
inline size_t IT_TimedCache<Key, Data, HashFn, Equal>::max() const
{
    return m_max;
}    

template<class Key, class Data, class HashFn, class Equal>
inline unsigned long IT_TimedCache<Key, Data, HashFn, Equal>::timeout() const
{
    return m_timeout;
}    

template<class Key, class Data, class HashFn, class Equal>
inline size_t IT_TimedCache<Key, Data, HashFn, Equal>::size() const
{
    return m_map.size();
}    

template<class Key, class Data, class HashFn, class Equal>
void IT_TimedCache<Key, Data, HashFn, Equal>::enforce()
{
    enforce_timeout();
    enforce_max();
}    

#if IT_SUPPORTS_COMPILE_TIME_INSTANTIATION
#include "timed_cache.cxx"
#endif

#endif  

---