any_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_ANY_MAP_H
#define MOD_SERVLET_ANY_MAP_H

#include <map>
#include <unordered_map>
#include <experimental/any>

#include <servlet/lib/optional.h>

namespace servlet
{

using std::experimental::any;
using std::experimental::any_cast;

template<typename _MapType>
class any_map : public _MapType
{
public:
    typedef _MapType                    map_type;

    typedef typename map_type::key_type        key_type;
    typedef typename map_type::mapped_type     mapped_type;
    typedef typename map_type::value_type      value_type;
    typedef typename map_type::allocator_type  allocator_type;
    typedef          value_type&               reference;
    typedef          const value_type&         const_reference;
    typedef typename map_type::pointer         pointer;
    typedef typename map_type::const_pointer   const_pointer;
    typedef typename map_type::size_type       size_type;
    typedef typename map_type::difference_type difference_type;

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

    any_map() = default;
    template<typename... Args>
    any_map(Args &&... args) : map_type{std::forward<Args>(args)...} {}

    ~any_map() = default;

    template<typename... Args>
    any_map& operator=(Args &&... args) { map_type::operator=(std::forward<Args>(args)...); return *this; }

    template<typename KeyType>
    bool contains_key(const KeyType &key) const { return this->find(key) != this->end(); }

    template<typename T, typename KeyType>
    optional_ref<const T> get(const KeyType& key) const
    {
        auto it = this->find(key);
        return it == this->end() ? optional_ref<const T>{} : optional_ref<const T>{any_cast<const T&>(it->second)};
    }
    template<typename T, typename KeyType>
    optional_ref<T> get(const KeyType& key)
    {
        auto it = this->find(key);
        return it == this->end() ? optional_ref<T>{} : optional_ref<T>{any_cast<T&>(it->second)};
    }

    template<typename T, typename... Args>
    T& ensure_get(key_type&& key, Args &&... args)
    {
        std::pair<iterator, bool> res = this->try_emplace(std::move(key));
        if (res.second) res.first->second = T{std::forward<Args>(args)...};
        return any_cast<T&>(res.first->second);
    }
    template<typename T, typename... Args>
    T& ensure_get(const key_type& key, Args &&... args)
    {
        std::pair<iterator, bool> res = this->try_emplace(key);
        if (res.second) res.first->second = T{std::forward<Args>(args)...};
        return any_cast<T&>(res.first->second);
    }

    template<typename T, typename... Args>
    bool put(key_type&& key, Args &&... args)
    {
        std::pair<iterator, bool> res = this->try_emplace(std::move(key));
        res.first->second = T{std::forward<Args>(args)...};
        return res.second;
    }
    template<typename T, typename... Args>
    bool put(const key_type& key, Args &&... args)
    {
        std::pair<iterator, bool> res = this->try_emplace(key);
        res.first->second = T{std::forward<Args>(args)...};
        return res.second;
    }
};

template <typename _Key = std::string, typename _Compare = std::less<>,
          typename _Alloc = std::allocator<std::pair<const _Key, any>>>
using tree_any_value_map = any_map<std::map<_Key, any, _Compare, _Alloc>>;

using tree_any_map = any_map<std::map<std::string, any, std::less<>>>;

template <typename _Key = std::string, typename _Hash = std::hash<_Key>,
          typename _Pred = std::equal_to<_Key>, typename _Alloc = std::allocator<std::pair<const _Key, any>>>
using hash_any_value_map = any_map<std::unordered_map<_Key, any, _Hash, _Pred, _Alloc>>;

using hash_any_map = any_map<std::unordered_map<std::string, any>>;

} // end of servlet namespace

#endif // MOD_SERVLET_ANY_MAP_H