HashMap.hpp

#pragma once
#include <unordered_map>

namespace samchon
{
    template <typename Key, typename T, 
              typename Hash = std::hash<Key>, typename Pred = std::equal_to<Key>, 
              typename Alloc = std::allocator<std::pair<const Key, T>>>
    class HashMap
        : public std::unordered_map<Key, T, Hash, Pred, Alloc>
    {
    private:
        typedef std::unordered_map<Key, T, Hash, Pred, Alloc> super;

        //PROHIBIT ACCESS BY AT
        auto at(const Key &) -> T& = delete;
        auto at(const Key &) const -> const T& = delete;

    public:
        using super::super;

        auto has(const Key &key) const -> bool
        {
            return count(key) != 0;
        };

        auto get(const Key &key) -> T&
        {
            return find(key)->second;
        };
        auto get(const Key &key) const -> const T&
        {
            return find(key)->second;
        };

        void set(const Key &key, const T &val)
        {
            iterator it = find(key);
            if (it != end())
                erase(it);

            insert({ key, val });
        };
        void set(const Key &key, const T &&val)
        {
            iterator it = find(key);
            if (it != end())
                erase(it);

            insert({ key, val });
        };

        auto pop(const Key &key) -> T
        {
            iterator it = find(key);
            T val = it->second;

            erase(it);

            return val;
        };
    };
};