enum_metadata.hpp

// Copyright Take Vos 2021.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "required.hpp"
#include "cast.hpp"
#include "assert.hpp"
#include <cstddef>
#include <type_traits>
#include <array>
#include <algorithm>
 
namespace hi::inline v1 {
 
template<typename T, std::size_t N>
class enum_metadata {
    static_assert(std::is_enum_v<T>, "Must be an enum");
    static_assert(N != 0);
 
public:
    using value_type = T;
 
    static constexpr std::size_t count = N;
 
    bool values_are_continues;
 
    [[nodiscard]] constexpr value_type minimum() const noexcept
    {
        return std::get<0>(_by_value).value;
    }
 
    [[nodiscard]] constexpr value_type maximum() const noexcept
    {
        return std::get<N-1>(_by_value).value;
    }
 
    template<typename... Args>
    [[nodiscard]] constexpr enum_metadata(Args const &...args) noexcept
    {
        static_assert(sizeof...(Args) == N * 2);
        add_value_name<0>(args...);
 
        std::sort(_by_name.begin(), _by_name.end(), [](hilet &a, hilet &b) {
            return a.name < b.name;
        });
 
        std::sort(_by_value.begin(), _by_value.end(), [](hilet &a, hilet &b) {
            return to_underlying(a.value) < to_underlying(b.value);
        });
 
        values_are_continues = check_values_are_continues();
    }
 
    [[nodiscard]] constexpr bool contains(std::string_view name) const noexcept
    {
        return find(name) != nullptr;
    }
 
    [[nodiscard]] constexpr bool contains(value_type value) const noexcept
    {
        return find(value) != nullptr;
    }
 
    [[nodiscard]] constexpr value_type at(std::string_view name) const
    {
        if (hilet *value = find(name)) {
            return *value;
        } else {
            throw std::out_of_range{"enum_metadata::at"};
        }
    }
 
    [[nodiscard]] constexpr std::string_view const &at(value_type value) const
    {
        if (hilet *name = find(value)) {
            return *name;
        } else {
            throw std::out_of_range{"enum_metadata::at"};
        }
    }
 
    [[nodiscard]] constexpr value_type at(std::string_view name, value_type default_value) const noexcept
    {
        if (hilet *value = find(name)) {
            return *value;
        } else {
            return default_value;
        }
    }
 
    [[nodiscard]] constexpr std::string_view at(value_type value, std::string_view default_name) const noexcept
    {
        if (hilet *name = find(value)) {
            return *name;
        } else {
            return default_name;
        }
    }
 
    [[nodiscard]] constexpr value_type operator[](std::string_view name) const noexcept
    {
        auto *value = find(name);
        hi_axiom(value != nullptr);
        return *value;
    }
 
    [[nodiscard]] constexpr std::string_view const &operator[](value_type value) const noexcept
    {
        auto *name = find(value);
        hi_axiom(name != nullptr);
        return *name;
    }
 
private:
    struct value_name {
        value_type value;
        std::string_view name;
 
        constexpr value_name() noexcept : value(), name() {}
        constexpr value_name(value_type value, std::string_view name) noexcept : value(value), name(name) {}
    };
 
    std::array<value_name, N> _by_name;
    std::array<value_name, N> _by_value;
 
    [[nodiscard]] constexpr std::string_view const *find(value_type value) const noexcept
    {
        if (values_are_continues) {
            // If the enum values are continues we can do an associative lookup.
            hilet it = _by_value.begin();
            hilet offset = to_underlying(it->value);
            hilet i = to_underlying(value) - offset;
            return (i >= 0 and i < N) ? &(it + i)->name : nullptr;
 
        } else {
            hilet it = std::lower_bound(_by_value.begin(), _by_value.end(), value, [](hilet &item, hilet &key) {
                return item.value < key;
            });
 
            return (it != _by_value.end() and it->value == value) ? &it->name : nullptr;
        }
    }
 
    [[nodiscard]] constexpr value_type const *find(std::string_view name) const noexcept
    {
        hilet it = std::lower_bound(_by_name.begin(), _by_name.end(), name, [](hilet &item, hilet &key) {
            return item.name < key;
        });
 
        return (it != _by_name.end() and it->name == name) ? &it->value : nullptr;
    }
 
    template<std::size_t I, typename... Rest>
    constexpr void add_value_name(value_type value, std::string_view name, Rest const &...rest) noexcept
    {
        static_assert(sizeof...(Rest) % 2 == 0);
 
        std::get<I>(_by_name) = {value, name};
        std::get<I>(_by_value) = {value, name};
 
        if constexpr (sizeof...(Rest) > 0) {
            add_value_name<I + 1>(rest...);
        }
    }
 
    [[nodiscard]] constexpr bool check_values_are_continues() const noexcept
    {
        auto check_value = to_underlying(minimum());
        for (hilet &item : _by_value) {
            if (to_underlying(item.value) != check_value++) {
                return false;
            }
        }
        return true;
    }
};
 
template<typename T, typename... Rest>
enum_metadata(T const &, Rest const &...) -> enum_metadata<T, (sizeof...(Rest) + 1) / 2>;
 
} // namespace hi