comptime_map.h

Go to the documentation of this file.

#ifndef KOUTIL_CONTAINER_COMPTIME_MAP_H
#define KOUTIL_CONTAINER_COMPTIME_MAP_H
 
#include "koutil/type/array_concat.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 comptime_map {
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 comptime_map(pairs_t pairs)
        : m_data(std::move(pairs)) {
 
        if (contains_duplicate_key()) {
            assert(false && "Duplicate keys are not allowed in a compile-time map.");
        }
        std::ranges::sort(m_data, {}, &pair_t::first);
    }
 
    template <std::size_t Count> [[nodiscard]] consteval auto extend(const std::array<pair_t, Count>& pairs) const {
        return comptime_map<Key, Value, Size + Count>(type::array_concat(m_data, pairs));
    }
 
    [[nodiscard]] consteval auto extend(const pair_t& pair) const {
        return comptime_map<Key, Value, Size + 1>(type::array_concat(m_data, std::array<pair_t, 1>({ pair })));
    }
 
    template <std::size_t OtherSize>
    [[nodiscard]] consteval auto extend(const comptime_map<Key, Value, OtherSize>& other) const {
        return extend(other.m_data);
    }
 
    [[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 comptime_map<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 comptime_map<Key, Value, Size> to_map(std::pair<Key, Value> (&&pairs)[Size]) {
    return { std::to_array(pairs) };
}
 
}
 
#endif