129 lines
4.3 KiB
C++
129 lines
4.3 KiB
C++
#include <climits>
|
|
#include <google/sparse_hash_map>
|
|
#include <iostream>
|
|
#include <list>
|
|
#include <vector>
|
|
|
|
template < class T >
|
|
struct Countfn {
|
|
unsigned long operator()( const T &x ) { return 1; }
|
|
};
|
|
|
|
template< class Key, class Data, class Sizefn = Countfn< Data > > class LRUCache {
|
|
public:
|
|
typedef std::list< std::pair< Key, Data > > List; ///< Main cache storage typedef
|
|
typedef typename List::iterator List_Iter; ///< Main cache iterator
|
|
typedef typename List::const_iterator List_cIter; ///< Main cache iterator (const)
|
|
typedef std::vector< Key > Key_List; ///< List of keys
|
|
typedef typename Key_List::iterator Key_List_Iter; ///< Main cache iterator
|
|
typedef typename Key_List::const_iterator Key_List_cIter; ///< Main cache iterator (const)
|
|
typedef google::sparse_hash_map< Key, List_Iter > Map; ///< Index typedef
|
|
typedef std::pair< Key, List_Iter > Pair; ///< Pair of Map elements
|
|
typedef typename Map::iterator Map_Iter; ///< Index iterator
|
|
typedef typename Map::const_iterator Map_cIter; ///< Index iterator (const)
|
|
|
|
private:
|
|
List _list; ///< Main cache storage
|
|
Map _index; ///< Cache storage index
|
|
unsigned long _max_size; ///< Maximum abstract size of the cache
|
|
unsigned long _curr_size; ///< Current abstract size of the cache
|
|
|
|
public:
|
|
LRUCache( const unsigned long Size ) : _max_size( Size ), _curr_size( 0 ) {
|
|
_index.set_deleted_key(UINT_MAX);
|
|
}
|
|
|
|
~LRUCache() { clear(); }
|
|
|
|
inline const unsigned long size( void ) const { return _curr_size; }
|
|
|
|
inline const unsigned long max_size( void ) const { return _max_size; }
|
|
|
|
/// Clears all storage and indices.
|
|
void clear( void ) {
|
|
_list.clear();
|
|
_index.clear();
|
|
};
|
|
|
|
inline bool exists( const Key &key ) const {
|
|
return _index.find( key ) != _index.end();
|
|
}
|
|
|
|
inline void remove( const Key &key ) {
|
|
Map_Iter miter = _index.find( key );
|
|
if( miter == _index.end() ) return;
|
|
_remove( miter );
|
|
}
|
|
|
|
inline void touch( const Key &key ) {
|
|
_touch( key );
|
|
}
|
|
|
|
inline Data *fetch_ptr( const Key &key, bool touch = true ) {
|
|
Map_Iter miter = _index.find( key );
|
|
if( miter == _index.end() ) return NULL;
|
|
_touch( key );
|
|
return &(miter->second->second);
|
|
}
|
|
|
|
inline bool fetch( const Key &key, Data &data, bool touch_data = true ) {
|
|
Map_Iter miter = _index.find( key );
|
|
if( miter == _index.end() ) return false;
|
|
if( touch_data )
|
|
_touch( key );
|
|
data = miter->second->second;
|
|
return true;
|
|
}
|
|
|
|
inline void insert( const Key &key, const Data data ) {
|
|
// Touch the key, if it exists, then replace the content.
|
|
Map_Iter miter = _touch( key );
|
|
if( miter != _index.end() )
|
|
_remove( miter );
|
|
|
|
// Ok, do the actual insert at the head of the list
|
|
_list.push_front( std::make_pair( key, data ) );
|
|
List_Iter liter = _list.begin();
|
|
|
|
// Store the index
|
|
_index.insert( std::make_pair( key, liter ) );
|
|
_curr_size += Sizefn()( data );
|
|
|
|
// Check to see if we need to remove an element due to exceeding max_size
|
|
while( _curr_size > _max_size ) {
|
|
std::cout << "removing element " << std::endl;
|
|
// Remove the last element.
|
|
liter = _list.end();
|
|
--liter;
|
|
_remove( liter->first );
|
|
}
|
|
}
|
|
|
|
inline const Key_List get_all_keys( void ) {
|
|
Key_List ret;
|
|
for( List_cIter liter = _list.begin(); liter != _list.end(); liter++ )
|
|
ret.push_back( liter->first );
|
|
return ret;
|
|
}
|
|
|
|
private:
|
|
inline Map_Iter _touch( const Key &key ) {
|
|
Map_Iter miter = _index.find( key );
|
|
if( miter == _index.end() ) return miter;
|
|
// Move the found node to the head of the list.
|
|
_list.splice( _list.begin(), _list, miter->second );
|
|
return miter;
|
|
}
|
|
|
|
inline void _remove( const Map_Iter &miter ) {
|
|
_curr_size -= Sizefn()( miter->second->second );
|
|
_list.erase( miter->second );
|
|
_index.erase( miter );
|
|
}
|
|
|
|
inline void _remove( const Key &key ) {
|
|
Map_Iter miter = _index.find( key );
|
|
_remove( miter );
|
|
}
|
|
};
|