comptime_map.h

Go to the documentation of this file.

#ifndef KOUTIL_CONTAINER_COMPTIME_MAP_H
#define KOUTIL_CONTAINER_COMPTIME_MAP_H
 
#include <algorithm>
#include <array>
#include <cassert>
#include <cstddef>
#include <limits>
#include <utility>
 
namespace koutil::container {
 
template <typename Key, typename Value, std::size_t Size> class ComptimeMap {
public:
    using pair_t               = std::pair<Key, Value>;
    using pairs_t              = std::array<pair_t, Size>;
    static constexpr auto npos = std::numeric_limits<std::size_t>::max();
 
    consteval ComptimeMap(pairs_t pairs)
        : m_data(std::move(pairs)) {
 
        if (contains_duplicate_key()) {
            assert(false);
        }
        std::ranges::sort(m_data, {}, &pair_t::first);
    }
 
    [[nodiscard]] consteval bool contains_duplicate_key() const {
 
        for (std::size_t i = 0; i < Size; i++) {
            for (std::size_t j = i + 1; j < Size; j++) {
                if (m_data[i].first == m_data[j].first) {
                    return true;
                }
            }
        }
 
        return false;
    }
 
    [[nodiscard]] constexpr std::size_t find(const Key& key) const {
 
        const auto iter = std::ranges::lower_bound(m_data.begin(), m_data.end(), key, {}, &pair_t::first);
        if (iter == m_data.end() || iter->first != key) {
            return npos;
        } else {
            return std::distance(m_data.begin(), iter);
        }
    }
 
    [[nodiscard]] constexpr const Value& operator[](const Key& key) const { return get(key); }
 
    [[nodiscard]] constexpr const Value& at(const Key& key) const {
        const auto index = find(key);
        return unsafe_get(index);
    }
 
    [[nodiscard]] constexpr const Value& safe_at(const Key& key, const Value& default_value) const {
        const auto index = find(key);
        return (index == npos) ? default_value : unsafe_get(index);
    }
 
    [[nodiscard]] constexpr const Value& unsafe_get(std::size_t index) const { return m_data[index].second; }
 
    [[nodiscard]] constexpr const pair_t& get_pair(const Key& key) const { return m_data[find(key)]; }
 
    [[nodiscard]] constexpr bool contains(const Key& key) const { return find(key) != npos; }
 
    [[nodiscard]] consteval bool test_value(const Value& value) const {
 
        for (auto&& [_, val] : m_data) {
            if (val == value) {
                return true;
            }
        }
 
        return false;
    }
 
    [[nodiscard]] consteval bool test_no_value(const Value& value) const { return !test_value(value); }
 
private:
    pairs_t m_data;
};
 
template <typename Key, typename Value, std::size_t Size>
consteval ComptimeMap<Key, Value, Size> to_map(std::array<std::pair<Key, Value>, Size> pairs) {
    return { pairs };
}
 
template <typename Key, typename Value, std::size_t Size>
// NOLINTNEXTLINE(modernize-avoid-c-arrays)
consteval ComptimeMap<Key, Value, Size> to_map(std::pair<Key, Value> (&&pairs)[Size]) {
    return { std::to_array(pairs) };
}
 
}
 
#endif