EnumString.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2025-2026 Vincent Leroy
// SPDX-License-Identifier: MIT
//
// This file is part of dfx.
//
// Licensed under the MIT License. See the LICENSE file in the project root
// for full license information.
 
#pragma once
 
// Standard includes
#include <format>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
// Project includes
#include "CompilerSupport.hpp"
#include "Macro.hpp"

 
#ifndef DOXYGEN_ONLY
#define DFX_BUILDER_ENUM_TO_STRING_MAPPING_IMPL(v, l)       case v: return l;
#define DFX_ENUM_TO_STRING_GENERATE_MAPPING(...)            DFX_GENERATOR_2_X(DFX_BUILDER_ENUM_TO_STRING_MAPPING_IMPL, __VA_ARGS__)
 
#define DFX_BUILDER_ENUM_FROM_STRING_MAPPING_IMPL(v, l)     { v, l },
#define DFX_ENUM_FROM_STRING_GENERATE_MAPPING(...)          DFX_GENERATOR_2_X(DFX_BUILDER_ENUM_FROM_STRING_MAPPING_IMPL, __VA_ARGS__)
 
#define DFX_BUILDER_ENUM_STRING_ONE_OUT_OF_TWO_1_IMPL(v, l) v,
#define DFX_ENUM_STRING_ONE_OUT_OF_TWO_1(...)               DFX_GENERATOR_2_X(DFX_BUILDER_ENUM_STRING_ONE_OUT_OF_TWO_1_IMPL, __VA_ARGS__)
 
#define DFX_BUILDER_ENUM_STRING_ONE_OUT_OF_TWO_2_IMPL(v, l) l,
#define DFX_ENUM_STRING_ONE_OUT_OF_TWO_2(...)               DFX_GENERATOR_2_X(DFX_BUILDER_ENUM_STRING_ONE_OUT_OF_TWO_2_IMPL, __VA_ARGS__)
#endif

#define DFX_ENUM_TO_STRING_IMPL(E, ...) \
    namespace dfx::Enum \
    { \
        [[nodiscard]] std::string_view toStringView(E e) noexcept \
        { \
            switch (e) \
            { \
                DFX_ENUM_TO_STRING_GENERATE_MAPPING(__VA_ARGS__) \
            } \
            DFX_UNREACHABLE_IMPL(); \
        } \
        [[nodiscard]] std::string toString(E e) noexcept \
        { return std::string(toStringView(e)); } \
    } // !namespace dfx::Enum
 
#ifdef DOXYGEN_ONLY
namespace dfx::Enum
{
    template<typename E>
    [[nodiscard]] std::string_view toStringView(E e) noexcept;
    template<typename E>
    [[nodiscard]] std::string toString(E e) noexcept;
}
#endif

namespace dfx::Enum
{
    template<typename E>
    [[nodiscard]] std::optional<E> fromStringView(std::string_view) noexcept = delete;

    template<typename E>
    [[nodiscard]] std::optional<E> fromString(std::string const &) noexcept = delete;
} // !namespace dfx::Enum

#define DFX_ENUM_FROM_STRING_IMPL(E) \
    namespace dfx::Enum \
    { \
        template<> \
        [[nodiscard]] std::optional<E> fromStringView(std::string_view str) noexcept \
        { \
            auto const & map = allValuesMapView<E>(); \
            auto const itr   = map.find(str); \
            if (itr == map.end()) \
                return std::nullopt; \
            return itr->second; \
        } \
        template<> \
        [[nodiscard]] std::optional<E> fromString(std::string const & str) noexcept \
        { return fromStringView<E>(str); } \
    } // !namespace dfx::Enum
 
/* Get all enum mapping values function */
namespace dfx::Enum
{
    template<typename E>
    [[nodiscard]] std::unordered_map<std::string, E> const & allValuesMap() noexcept = delete;

    template<typename E>
    [[nodiscard]] std::unordered_map<std::string_view, E> const & allValuesMapView() noexcept = delete;
} // !namespace dfx::Enum

#define DFX_ENUM_ALL_VALUES_MAP_IMPL(E, ...) \
    namespace dfx::Enum \
    { \
        template<> \
        [[nodiscard]] std::unordered_map<std::string, E> const & allValuesMap() noexcept \
        { \
            static std::unordered_map<std::string, E> const map = { \
                DFX_ENUM_FROM_STRING_GENERATE_MAPPING(__VA_ARGS__) \
            }; \
            return map; \
        } \
        template<> \
        [[nodiscard]] std::unordered_map<std::string_view, E> const & allValuesMapView() noexcept \
        { \
            static std::unordered_map<std::string_view, E> const map = { \
                DFX_ENUM_FROM_STRING_GENERATE_MAPPING(__VA_ARGS__) \
            }; \
            return map; \
        } \
    } // !namespace dfx::Enum
 
/* Get all enum values function */
namespace dfx::Enum
{
    template<typename E>
    [[nodiscard]] std::vector<E> const & allValues() noexcept = delete;

    template<typename E>
    [[nodiscard]] std::vector<std::string_view> const & allValuesStringView() noexcept = delete;
} // !namespace dfx::Enum

#define DFX_ENUM_ALL_VALUES_IMPL(E, ...) \
    namespace dfx::Enum \
    { \
        template<> \
        [[nodiscard]] std::vector<E> const & allValues() noexcept \
        { \
            static std::vector<E> const vec = { \
                DFX_ENUM_STRING_ONE_OUT_OF_TWO_1(__VA_ARGS__) \
            }; \
            return vec; \
        } \
        template<> \
        [[nodiscard]] std::vector<std::string_view> const & allValuesStringView<E>() noexcept \
        { \
            static std::vector<std::string_view> const vec = { \
                DFX_ENUM_STRING_ONE_OUT_OF_TWO_2(__VA_ARGS__) \
            }; \
            return vec; \
        } \
    } // !namespace dfx::Enum

#define DFX_ENUM_STD_FMT_FORMATTER(E) \
template<> \
struct std::formatter<E> : public formatter<std::string_view> \
{ \
    auto format(E const & e, format_context & ctx) const \
    { return formatter<std::string_view>::format(dfx::Enum::toStringView(e), ctx); } \
}

#define DFX_DEFINE_ENUM_STRING_FUNCTIONS(Enum, ...) \
    DFX_ENUM_TO_STRING_IMPL(Enum, __VA_ARGS__) \
    DFX_ENUM_FROM_STRING_IMPL(Enum) \
    DFX_ENUM_ALL_VALUES_MAP_IMPL(Enum, DFX_SWAP_POSITION(__VA_ARGS__)) \
    DFX_ENUM_ALL_VALUES_IMPL(Enum, __VA_ARGS__)

#define DFX_DECLARE_ENUM_STRING_FUNCTIONS(E) \
    namespace dfx::Enum \
    { \
        [[nodiscard]] std::string_view toStringView(E e) noexcept; \
        [[nodiscard]] std::string toString(E e) noexcept; \
        template<> [[nodiscard]] std::optional<E> fromStringView(std::string_view str) noexcept; \
        template<> [[nodiscard]] std::optional<E> fromString(std::string const & str) noexcept; \
        template<> [[nodiscard]] std::unordered_map<std::string_view, E> const & allValuesMapView() noexcept; \
        template<> [[nodiscard]] std::unordered_map<std::string, E> const & allValuesMap() noexcept; \
        template<> [[nodiscard]] std::vector<E> const & allValues() noexcept; \
        template<> [[nodiscard]] std::vector<std::string_view> const & allValuesStringView<E>() noexcept; \
    } \
    DFX_ENUM_STD_FMT_FORMATTER(E)