dict.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <initializer_list>
#include <unordered_map>
#include <utility>
 
// template <typename T> using Value_type = typename T::value_type;
 
namespace py {
 
    template <typename Iter> struct key_iterator : Iter {
        explicit key_iterator(Iter it) : Iter(it) {}
 
        auto operator*() const -> const auto& { return Iter::operator*().first; }
 
        auto operator*() -> const auto& { return Iter::operator*().first; }
 
        auto operator++() -> key_iterator& {
            Iter::operator++();
            return *this;
        }
        auto operator++(int) -> key_iterator {
            auto old = *this;
            ++*this;
            return old;
        }
    };
 
    template <typename Key, typename T> class dict : public std::unordered_map<Key, T> {
        using Self = dict<Key, T>;
        using Base = std::unordered_map<Key, T>;
 
      public:
        using value_type = std::pair<const Key, T>;
        using key_type = Key;
 
        dict() : Base{} {}
 
        dict(std::initializer_list<value_type> init) : Base{init} {}
 
        auto contains(const Key& key) const -> bool { return this->find(key) != this->end(); }
 
        auto get(const Key& key, const T& default_value) const -> T {
            if (!contains(key)) {
                return default_value;
            }
            return this->at(key);
        }
 
        auto begin() -> key_iterator<decltype(Base::begin())> {
            return key_iterator<decltype(Base::begin())>{Base::begin()};
        }
 
        auto end() -> key_iterator<decltype(Base::end())> {
            return key_iterator<decltype(Base::end())>{Base::end()};
        }
 
        auto begin() const -> key_iterator<decltype(Base::begin())> {
            return key_iterator<decltype(Base::begin())>{Base::begin()};
        }
 
        auto end() const -> key_iterator<decltype(Base::end())> {
            return key_iterator<decltype(Base::end())>{Base::end()};
        }
 
        auto items() -> Base& { return *this; }
 
        auto items() const -> const Base& { return *this; }
 
        auto copy() const -> Self { return *this; }
 
        auto operator[](const Key& k) const -> const T& {
            return Base::at(k);  // luk: a bug in std::unordered_map?
        }
 
        auto at(const Key& k) const -> const T& {
            return Base::at(k);  // luk: a bug in std::unordered_map?
        }
 
        auto operator[](const Key& k) -> T& { return Base::operator[](k); }
 
        auto operator=(const Self&) -> Self& = delete;
 
        auto operator=(Self&&) noexcept -> dict& = default;
 
        dict(dict<Key, T>&&) noexcept = default;
 
        ~dict() = default;
 
        // private:
        dict(const dict<Key, T>&) = default;
    };
 
    template <typename Key, typename T>
    inline auto operator<(const Key& key, const dict<Key, T>& m) noexcept -> bool {
        return m.contains(key);
    }
 
    template <typename Key, typename T> inline auto len(const dict<Key, T>& m) noexcept -> size_t {
        return m.size();
    }
 
    // template <typename Key, typename T>
    // dict(std::initializer_list<std::pair<const Key, T>>) -> dict<Key, T>;
 
    // template <class Sequence>
    // dict(const Sequence& S)
    //     -> dict<std::remove_cv_t<decltype(*std::begin(S))>, size_t>;
 
}  // namespace py