cache.hpp

Go to the documentation of this file.

 
#ifndef CACHE_HPP
#define CACHE_HPP
 
#include "cache_policy.hpp"
 
#include <algorithm>
#include <cstddef>
#include <functional>
#include <limits>
#include <memory>
#include <mutex>
#include <stdexcept>
#include <unordered_map>
 
namespace caches
{
template <typename V>
using WrappedValue = std::shared_ptr<V>;
 
template <typename Key, typename Value, template <typename> class Policy = NoCachePolicy,
          typename HashMap = std::unordered_map<Key, WrappedValue<Value>>>
class fixed_sized_cache
{
  public:
    using map_type = HashMap;
    using value_type = typename map_type::mapped_type;
    using iterator = typename map_type::iterator;
    using const_iterator = typename map_type::const_iterator;
    using operation_guard = typename std::lock_guard<std::mutex>;
    using on_erase_cb =
        typename std::function<void(const Key &key, const value_type &value)>;
 
    explicit fixed_sized_cache(
        size_t max_size, const Policy<Key> policy = Policy<Key>{},
        on_erase_cb on_erase = [](const Key &, const value_type &) {})
        : cache_policy{policy}, max_cache_size{max_size}, on_erase_callback{on_erase}
    {
        if (max_cache_size == 0)
        {
            throw std::invalid_argument{"Size of the cache should be non-zero"};
        }
    }
 
    ~fixed_sized_cache() noexcept
    {
        Clear();
    }
 
    void Put(const Key &key, const Value &value) noexcept
    {
        operation_guard lock{safe_op};
        auto elem_it = FindElem(key);
 
        if (elem_it == cache_items_map.end())
        {
            // add new element to the cache
            if (cache_items_map.size() + 1 > max_cache_size)
            {
                auto disp_candidate_key = cache_policy.ReplCandidate();
 
                Erase(disp_candidate_key);
            }
 
            Insert(key, value);
        }
        else
        {
            // update previous value
            Update(key, value);
        }
    }
 
    std::pair<value_type, bool> TryGet(const Key &key) const noexcept
    {
        operation_guard lock{safe_op};
        const auto result = GetInternal(key);
 
        return std::make_pair(result.second ? result.first->second : nullptr,
                              result.second);
    }
 
    value_type Get(const Key &key) const
    {
        operation_guard lock{safe_op};
        auto elem = GetInternal(key);
 
        if (elem.second)
        {
            return elem.first->second;
        }
        else
        {
            throw std::range_error{"No such element in the cache"};
        }
    }
 
    bool Cached(const Key &key) const noexcept
    {
        operation_guard lock{safe_op};
        return FindElem(key) != cache_items_map.cend();
    }
 
    std::size_t Size() const
    {
        operation_guard lock{safe_op};
 
        return cache_items_map.size();
    }
 
    bool Remove(const Key &key)
    {
        operation_guard lock{safe_op};
 
        auto elem = FindElem(key);
 
        if (elem == cache_items_map.end())
        {
            return false;
        }
 
        Erase(elem);
 
        return true;
    }
 
  protected:
    void Clear()
    {
        operation_guard lock{safe_op};
 
        std::for_each(begin(), end(),
                      [&](const std::pair<const Key, value_type> &el)
                      { cache_policy.Erase(el.first); });
        cache_items_map.clear();
    }
 
    const_iterator begin() const noexcept
    {
        return cache_items_map.cbegin();
    }
 
    const_iterator end() const noexcept
    {
        return cache_items_map.cend();
    }
 
  protected:
    void Insert(const Key &key, const Value &value)
    {
        cache_policy.Insert(key);
        cache_items_map.emplace(std::make_pair(key, std::make_shared<Value>(value)));
    }
 
    void Erase(const_iterator elem)
    {
        cache_policy.Erase(elem->first);
        on_erase_callback(elem->first, elem->second);
        cache_items_map.erase(elem);
    }
 
    void Erase(const Key &key)
    {
        auto elem_it = FindElem(key);
 
        Erase(elem_it);
    }
 
    void Update(const Key &key, const Value &value)
    {
        cache_policy.Touch(key);
        cache_items_map[key] = std::make_shared<Value>(value);
    }
 
    const_iterator FindElem(const Key &key) const
    {
        return cache_items_map.find(key);
    }
 
    std::pair<const_iterator, bool> GetInternal(const Key &key) const noexcept
    {
        auto elem_it = FindElem(key);
 
        if (elem_it != end())
        {
            cache_policy.Touch(key);
            return {elem_it, true};
        }
 
        return {elem_it, false};
    }
 
  private:
    map_type cache_items_map;
    mutable Policy<Key> cache_policy;
    mutable std::mutex safe_op;
    std::size_t max_cache_size;
    on_erase_cb on_erase_callback;
};
} // namespace caches
 
#endif // CACHE_HPP