Class HashMap

app/src/main/cpp/utils/HashMap.h:14–119

template<typename K, typename V, typename Hash = std::hash<K>, typename Pred = std::equal_to<K>>
class HashMap {
public:
    class Entry {
    public:
        Entry(const K &k, const V &v) : key(k), value(v) {}

        Entry(const Entry &) = delete;

        Entry &operator=(const Entry &) = delete;

        [[nodiscard]] K getKey() const {
            return key;
        }

        [[nodiscard]] V *getValue() const {
            return &value;
        }

        template<typename... Args>
        void setValue(Args &&...args) const {
            value = V(std::forward<Args>(args)...);
        }

        void setValue(V &v) const {
            value = v;
        }

    private:
        const K key;
        mutable V value;
    };

private:
    std::unordered_map<K, std::shared_ptr<Entry>, Hash, Pred> backend;
public:
    HashMap() = default;

    template<typename AnyMap>
    explicit HashMap(const AnyMap &map) {
        const auto entries = map.entrySet();
        for (const auto &entry: entries) {
            backend.insert_or_assign(entry->getKey(), std::make_shared<Entry>
                    (entry->getKey(), *entry->getValue()));
        }
    }

    [[nodiscard]] std::set<std::shared_ptr<Entry>> entrySet() const {
        std::set<std::shared_ptr<Entry>> copy = std::set<std::shared_ptr<Entry>>();
        for (const auto &entry: backend) {
            copy.emplace(entry.second);
        }
        return copy;
    }

    [[nodiscard]] size_t size() const {
        return backend.size();
    }