lru_map.h

Go to the documentation of this file.

/*
Copyright (c) 2016 Alexei Novakov
https://github.com/novalexei

Distributed under the Boost Software License, Version 1.0.
http://boost.org/LICENSE_1_0.txt
*/
#ifndef MOD_SERVLET_TIMED_MAP_H
#define MOD_SERVLET_TIMED_MAP_H

#include <map>
#include <unordered_map>

#include <servlet/lib/linked_map.h>

namespace servlet
{

template<typename T>
class timed_entry
{
public:
    typedef std::chrono::time_point<std::chrono::system_clock, std::chrono::system_clock::duration> tp_type;

    timed_entry(const T& value) : _value{value}, _last_modified{std::chrono::system_clock::now()} {}
    timed_entry(T&& value) : _value{std::move(value)}, _last_modified{std::chrono::system_clock::now()} {}
    timed_entry(const timed_entry& other) : _value{other._value}, _last_modified{std::chrono::system_clock::now()} {}
    timed_entry(timed_entry&& other) : _value{std::move(other._value)}, _last_modified{std::chrono::system_clock::now()} {}

    ~timed_entry() = default;

    timed_entry& operator=(const timed_entry& other)
    {
        _value = other._value; _last_modified = other._last_modified;
        return *this;
    }
    timed_entry& operator=(timed_entry&& other)
    {
        _value = std::move(other._value); _last_modified = other._last_modified;
        return *this;
    }
    timed_entry& operator=(const T& value) { _value = value; update_last_modified(); return *this; }
    timed_entry& operator=(T&& value) { _value = std::move(value); update_last_modified(); return *this; }

    operator T&() & { return _value; }
    operator T&&() && { return std::move(_value); }

    T& operator*() { return _value; }
    const T& operator*() const { return _value; }

    tp_type last_modified() { return _last_modified; }
    void update_last_modified() { _last_modified = std::chrono::system_clock::now(); }

private:
    T _value;
    tp_type _last_modified;
};
template<typename _Key, typename _Tp, typename _MT>
class lru_map : public linked_map<_Key, _Tp, _MT>
{
public:
    typedef linked_map<_Key, _Tp, _MT> base_type;

    typedef typename base_type::key_type     key_type;
    typedef typename base_type::mapped_type  mapped_type;
    typedef typename base_type::value_type   value_type;

    typedef typename base_type::allocator_type  allocator_type;
    typedef typename base_type::reference       reference;
    typedef typename base_type::const_reference const_reference;
    typedef typename base_type::pointer         pointer;
    typedef typename base_type::const_pointer   const_pointer;
    typedef typename base_type::size_type       size_type;
    typedef typename base_type::difference_type difference_type;

    typedef typename base_type::iterator               iterator;
    typedef typename base_type::const_iterator         const_iterator;
    typedef typename base_type::reverse_iterator       reverse_iterator;
    typedef typename base_type::const_reverse_iterator const_reverse_iterator;

    lru_map(std::size_t timeout_sec) : base_type{}, _timeout_sec{timeout_sec} {}
    lru_map(const lru_map& other) : base_type{other}, _timeout_sec{other._timeout_sec} {}
    lru_map(lru_map&& other) : base_type{std::move(other)}, _timeout_sec{other._timeout_sec} {}

    ~lru_map() = default;

    lru_map& operator=(const lru_map& other)
    {
        _timeout_sec = other._timeout_sec; base_type::operator=(other);
        return *this;
    }
    lru_map& operator=(lru_map&& other)
    {
        _timeout_sec = other._timeout_sec; base_type::operator=(std::move(other));
        return *this;
    }

    void set_timeout(std::size_t timeout_sec) { _timeout_sec = timeout_sec; }

    template<typename KeyType>
    bool contains_key(const KeyType &key) const
    {
        std::lock_guard<std::mutex> guard{_mutex};
        return base_type::contains_key(key);
    }

    void clear()
    {
        std::lock_guard<std::mutex> guard{_mutex};
        base_type::clear();
    }

    template<typename KeyType>
    optional_ref<const mapped_type> get(const KeyType& key) const
    {
        std::lock_guard<std::mutex> guard{_mutex};
        return base_type::get(key);
    }
    template<typename KeyType>
    optional_ref<mapped_type> get(const KeyType& key)
    {
        std::lock_guard<std::mutex> guard{_mutex};
        return base_type::get(key);
    }

    template<class... Args>
    bool put(key_type&& key, Args &&... args)
    {
        std::lock_guard<std::mutex> guard{_mutex};
        return base_type::put(std::move(key), std::forward<Args>(args)...);
    }
    template<class... Args>
    bool put(const key_type& key, Args &&... args)
    {
        std::lock_guard<std::mutex> guard{_mutex};
        return base_type::put(key, std::forward<Args>(args)...);
    }

    template<class... Args>
    bool try_put(key_type&& key, Args &&... args)
    {
        std::lock_guard<std::mutex> guard{_mutex};
        return base_type::try_put(std::move(key), std::forward<Args>(args)...);
    }

    template<class... Args>
    bool try_put(const key_type& key, Args &&... args)
    {
        std::lock_guard<std::mutex> guard{_mutex};
        return base_type::try_put(key, std::forward<Args>(args)...);
    }

    template<typename KeyType>
    bool erase(const KeyType &key)
    {
        std::lock_guard<std::mutex> guard{_mutex};
        return base_type::erase(key);
    }
protected:
    void update(value_type& val) const override { val.second.update_last_modified(); }

    void purge() override
    {
        auto now = std::chrono::system_clock::now();
        auto b = this->begin();
        auto e = this->end();
        while (b != e &&
               std::chrono::duration_cast<std::chrono::seconds>(now-b->second.last_modified()).count() > _timeout_sec)
        {
            const key_type& key_ref = b->first;
            ++b;
            this->erase(key_ref);
        }
    }
private:
    std::size_t _timeout_sec;
    mutable std::mutex _mutex;
};

template<typename _Key, typename _Value, typename _Compare = std::less<>,
         typename _Alloc = std::allocator<std::pair<const _Key,
                                                    typename std::list<std::pair<const _Key &, _Value>>::iterator>>>
using lru_tree_map = lru_map<_Key, timed_entry<_Value>,
                             std::map<_Key, typename std::list<std::pair<const _Key &, timed_entry<_Value>>>::iterator,
                                      _Compare, _Alloc>>;

template<typename _Key, typename _Value, typename _Hash = std::hash<_Key>,
         typename _Pred = std::equal_to<_Key>,
         typename _Alloc = std::allocator<std::pair<const _Key,
                                                    typename std::list<std::pair<const _Key &, _Value>>::iterator>>>
using lru_hash_map = lru_map<_Key, timed_entry<_Value>,
                             std::unordered_map<_Key, typename std::list<std::pair<const _Key &, timed_entry<_Value>>>::iterator,
                                                _Hash, _Pred, _Alloc>>;

} // end of servlet namespace

#endif // MOD_SERVLET_TIMED_MAP_H