LRUCache.hpp

#ifndef AETHER_LRUCACHE_HPP
#define AETHER_LRUCACHE_HPP

#include <functional>
#include <list>
#include <unordered_map>

namespace Aether {
    template <typename Key, typename Value>
    class LRUCache {
        public:
            // Typedef some really long things
            typedef typename std::pair<Key, Value> KeyValuePair;
            typedef typename std::list<KeyValuePair>::iterator ListIterator;

        private:
            std::list<KeyValuePair> items;

            std::unordered_map<Key, ListIterator> keyMap;

            std::function<void(const Key &, const Value &)> callback;

            unsigned int maxSize;

        public:
            LRUCache() {
                this->callback = nullptr;
                this->maxSize = 100;
            }

            LRUCache(const unsigned int size, const std::function<void(const Key &, const Value &)> & func = nullptr) {
                this->callback = func;
                this->maxSize = size;
            }

            void addData(const Key & key, const Value & data) {
                // Add data to front of cache
                typename std::unordered_map<Key, ListIterator>::iterator it = this->keyMap.find(key);
                this->items.push_front(KeyValuePair(key, data));
                if (it != this->keyMap.end()) {
                    // If it was in the map, remove old value
                    this->items.erase(it->second);
                    this->keyMap.erase(it);
                }
                this->keyMap[key] = this->items.begin();

                // If we're oversize, remove oldest element
                if (this->keyMap.size() > this->maxSize) {
                    // Get last element
                    typename std::list<KeyValuePair>::iterator it2 = this->items.end();
                    it2--;

                    // Invoke callback if one was set
                    if (this->callback != nullptr) {
                        this->callback(it2->first, it2->second);
                    }

                    // Remove from both containers
                    this->keyMap.erase(it2->first);
                    this->items.pop_back();
                }
            }

            Value getData(const Key & key) {
                typename std::unordered_map<Key, ListIterator>::iterator it = this->keyMap.find(key);
                if (it != this->keyMap.end()) {
                    // Shift data to front of list
                    this->items.splice(this->items.begin(), this->items, it->second);
                }

                // We hope this is a valid element if key doesn't exist
                return this->items.begin()->second;
            }

            bool hasKey(const Key & key) {
                return (this->keyMap.find(key) != this->keyMap.end());
            }

            unsigned int size() {
                return this->keyMap.size();
            }

            ~LRUCache() {
                if (this->callback != nullptr) {
                    for (const KeyValuePair & pair : this->items) {
                        this->callback(pair.first, pair.second);
                    }
                }
            }
    };
};

#endif