hashmap.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <unordered_map>
#include <initializer_list>
#include <promeki/namespace.h>
#include <promeki/sharedptr.h>
#include <promeki/list.h>
 
PROMEKI_NAMESPACE_BEGIN
 
template <typename K, typename V> class HashMap {
                PROMEKI_SHARED_FINAL(HashMap)
        public:
                using Ptr = SharedPtr<HashMap>;
 
                using Data = std::unordered_map<K, V>;
 
                using Key = K;
 
                using Value = V;
 
                using Iterator = typename Data::iterator;
 
                using ConstIterator = typename Data::const_iterator;
 
                HashMap() = default;
 
                HashMap(const HashMap &other) : d(other.d) {}
 
                HashMap(HashMap &&other) noexcept : d(std::move(other.d)) {}
 
                HashMap(std::initializer_list<std::pair<const K, V>> initList) : d(initList) {}
 
                ~HashMap() = default;
 
                HashMap &operator=(const HashMap &other) {
                        d = other.d;
                        return *this;
                }
 
                HashMap &operator=(HashMap &&other) noexcept {
                        d = std::move(other.d);
                        return *this;
                }
 
                // -- Iterators --
 
                Iterator begin() noexcept { return d.begin(); }
 
                ConstIterator begin() const noexcept { return d.cbegin(); }
 
                ConstIterator cbegin() const noexcept { return d.cbegin(); }
 
                ConstIterator constBegin() const noexcept { return d.cbegin(); }
 
                Iterator end() noexcept { return d.end(); }
 
                ConstIterator end() const noexcept { return d.cend(); }
 
                ConstIterator cend() const noexcept { return d.cend(); }
 
                ConstIterator constEnd() const noexcept { return d.cend(); }
 
                // -- Capacity --
 
                bool isEmpty() const noexcept { return d.empty(); }
 
                size_t size() const noexcept { return d.size(); }
 
                void reserve(size_t count) { d.reserve(count); }
 
                // -- Lookup --
 
                V &operator[](const K &key) { return d[key]; }
 
                const V &operator[](const K &key) const { return d.at(key); }
 
                V value(const K &key, const V &defaultValue = V{}) const {
                        auto it = d.find(key);
                        if (it != d.end()) return it->second;
                        return defaultValue;
                }
 
                bool contains(const K &key) const { return d.find(key) != d.end(); }
 
                Iterator find(const K &key) { return d.find(key); }
 
                ConstIterator find(const K &key) const { return d.find(key); }
 
                // -- Modifiers --
 
                void insert(const K &key, const V &val) {
                        d.insert_or_assign(key, val);
                        return;
                }
 
                void insert(const K &key, V &&val) {
                        d.insert_or_assign(key, std::move(val));
                        return;
                }
 
                bool insertNew(const K &key, const V &val) { return d.emplace(key, val).second; }
 
                template <typename... ArgsT> std::pair<Iterator, bool> tryEmplace(const K &key, ArgsT &&...args) {
                        return d.try_emplace(key, std::forward<ArgsT>(args)...);
                }
 
                bool remove(const K &key) { return d.erase(key) > 0; }
 
                Iterator remove(Iterator pos) { return d.erase(pos); }
 
                void clear() noexcept {
                        d.clear();
                        return;
                }
 
                void swap(HashMap &other) noexcept {
                        d.swap(other.d);
                        return;
                }
 
                // -- Convenience --
 
                List<K> keys() const {
                        List<K> ret;
                        ret.reserve(d.size());
                        for (const auto &[k, v] : d) ret.pushToBack(k);
                        return ret;
                }
 
                List<V> values() const {
                        List<V> ret;
                        ret.reserve(d.size());
                        for (const auto &[k, v] : d) ret.pushToBack(v);
                        return ret;
                }
 
                template <typename Func> void forEach(Func &&func) const {
                        for (const auto &[k, v] : d) func(k, v);
                        return;
                }
 
                // -- Comparison --
 
                friend bool operator==(const HashMap &lhs, const HashMap &rhs) { return lhs.d == rhs.d; }
 
                friend bool operator!=(const HashMap &lhs, const HashMap &rhs) { return lhs.d != rhs.d; }
 
        private:
                Data d;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE