unordered_map.h

Go to the documentation of this file.

 
#ifndef QB_UNORDERED_MAP_H
#define QB_UNORDERED_MAP_H
#include <string>
#include <map>
#include <ska_hash/unordered_map.hpp>
#include <unordered_map>
 
namespace qb {

template <typename K, typename V, typename H = std::hash<K>,
          typename E = std::equal_to<K>,
          typename A = std::allocator<std::pair<const K, V>>>
using unordered_flat_map = ska::flat_hash_map<K, V, H, E, A>;
 
#ifdef NDEBUG
template <typename K, typename V, typename H = std::hash<K>,
          typename E = std::equal_to<K>,
          typename A = std::allocator<std::pair<const K, V>>>
using unordered_map = ska::unordered_map<K, V, H, E, A>;
#else
template <typename K, typename V, typename H = std::hash<K>,
          typename E = std::equal_to<K>,
          typename A = std::allocator<std::pair<const K, V>>>
using unordered_map = std::unordered_map<K, V, H, E, A>;
#endif

class string_to_lower {
    constexpr static char
    charToLower(const char c) {
        return (c >= 'A' && c <= 'Z') ? c + ('a' - 'A') : c;
    }

    template <std::size_t N>
    class const_str {
    private:
        const char s[N + 1]; // One extra byte to fill with a 0 value
 
    public:
        template <typename T, T... Nums>
        constexpr const_str(const char (&str)[N], std::integer_sequence<T, Nums...>)
            : s{charToLower(str[Nums])..., 0} {}

        constexpr char
        operator[](std::size_t i) const {
            return s[i];
        }

        operator const char *() const {
            return s;
        }
    };

    template <std::size_t N>
    constexpr static const_str<N>
    toLower(const char (&str)[N]) {
        return {str, std::make_integer_sequence<unsigned, N>()};
    }
 
public:
    template <std::size_t N>
    static std::string
    convert(const char (&str)[N]) {
        return std::string{toLower(str), N - 1};
    }

    static std::string
    convert(std::string const &str) {
        std::string copy;
        copy.reserve(str.size());
        std::for_each(str.cbegin(), str.cend(),
                      [&copy](const char &c) { copy += charToLower(c); });
        return copy;
    }

    static std::string
    convert(std::string_view const &str) {
        std::string copy;
        copy.reserve(str.size());
        std::for_each(str.cbegin(), str.cend(),
                      [&copy](const char &c) { copy += charToLower(c); });
        return copy;
    }
};

template <typename _Map, typename _Trait = string_to_lower>
class icase_basic_map : _Map {
    using base_t = _Map;
 
public:
    icase_basic_map() = default;

    icase_basic_map(icase_basic_map const &) = default;

    icase_basic_map(icase_basic_map &&) noexcept = default;

    icase_basic_map(std::initializer_list<typename _Map::value_type> il) {
        for (auto &it : il)
            emplace(it.first, std::move(it.second));
    }

    icase_basic_map &operator=(icase_basic_map const &) = default;

    icase_basic_map &operator=(icase_basic_map &&) noexcept = default;

    template <typename T, typename... _Args>
    auto
    emplace(T &&key, _Args &&...args) {
        return static_cast<base_t &>(*this).emplace(
            _Trait::convert(std::forward<T>(key)), std::forward<_Args>(args)...);
    }

    template <typename T, typename... _Args>
    auto
    try_emplace(T &&key, _Args &&...args) {
        return static_cast<base_t &>(*this).try_emplace(
            _Trait::convert(std::forward<T>(key)), std::forward<_Args>(args)...);
    }

    template <typename T>
    auto &
    at(T &&key) {
        return static_cast<base_t &>(*this).at(_Trait::convert(std::forward<T>(key)));
    }

    template <typename T>
    const auto &
    at(T &&key) const {
        return static_cast<base_t const &>(*this).at(
            _Trait::convert(std::forward<T>(key)));
    }

    template <typename T>
    auto &
    operator[](T &&key) {
        return static_cast<base_t &>(*this)[_Trait::convert(std::forward<T>(key))];
    }

    template <typename T>
    auto
    find(T &&key) {
        return static_cast<base_t &>(*this).find(_Trait::convert(std::forward<T>(key)));
    }

    template <typename T>
    auto
    find(T &&key) const {
        return static_cast<base_t const &>(*this).find(
            _Trait::convert(std::forward<T>(key)));
    }

    template <typename T>
    bool
    has(T &&key) const {
        return find(std::forward<T>(key)) != this->cend();
    }

    template <typename T>
    auto
    erase(T &&key) {
        return static_cast<base_t &>(*this).erase(_Trait::convert(std::forward<T>(key)));
    }
 
    // Import methods from the base map
    using base_t::begin;
    using base_t::cbegin;
    using base_t::cend;
    using base_t::clear;
    using base_t::end;
    using base_t::erase;
    using base_t::size;
    using base_t::empty;

    template <typename T>
    static std::string
    convert_key(T &&key) noexcept {
        return _Trait::convert(std::forward<T>(key));
    }
};

template <typename Value, typename _Trait = string_to_lower>
using icase_map = icase_basic_map<std::map<std::string, Value>, _Trait>;

template <typename Value, typename _Trait = string_to_lower>
using icase_unordered_map =
    icase_basic_map<qb::unordered_map<std::string, Value>, _Trait>;
 
} // namespace qb
 
#endif // QB_UNORDERED_MAP_H