LRUCache

This is my implementation of a LRU (Least Recently Used) Cache. The cache will store values and keep track of what was accessed most recently. This is great to help reduce the amount of repetitive malloc calls, for example.

This implementation differs from most in that:

1. It is associate
2. Get always returns a value

The big use for me was get() creating values. If a value is not found in the cache, it creates the value T(Key) and returns that. This does not have to be used, however, if you only use get() on values you are positive have been put() into the cache.

To use this in a project, just copy lru.hpp into your own projects source tree. The namespace it uses is clortox

Run tests

You can run the test suite with the following:

make sanity

# Relies on gprof
make profile

Interface

Constructors

LRUCache()
LRUCache(size_t max_size)

Defaults size of cache to 50

Utility

void clear()

Clears out the contents of the cache

bool empty() const

Returns true if the cache is empty

bool full() const

Returns true if the cache is full

size_t getMaxCacheSize() const

Returns the cache size, passed as max_size when constructing

Accessors

T& get(const Key&)
T& operator[](const Key&)
T& operator[](Key&)

Returns T associated with Key. If none exists, creates T(key), inserts it into the cache, and returns a reference to it

void put(const Key&, const T&)

Places (Key, T) into the cache as the most recent item

bool erase(const Key&)

Erases element associated with Key. Use this if you know that item is not likely to accessed soon and would like to delete ahead of time

void pop_back()

Removes oldest element from the cache. Can be used, however is more often used internally