Compiler Explorer

Source code

#include <algorithm>
#include <exception>
#include <expected>
#include <functional>
#include <iostream>
#include <locale>
#include <ranges>
#include <sstream>
#include <stdexcept>
#include <string>
#include <string_view>
#include <tuple>
#include <type_traits>
#include <utility>

#include <experimental/meta>

namespace indi {

// Useful concept. Not necessary, but handy.
template<typename T>
concept enumeration = std::is_enum_v<T>;

//////////////////////////////////////////////////////////////////////////////
// class enumeration_string_mapping_type<E>;
// consteval auto default_enumeration_string_map<E>() ->
//      std::array<enumeration_string_mapping_type<E>, N>;
// enumeration_string_map<E> ->
//      std::array<enumeration_string_mapping_type<E>, N>;
//
// Mapping of enumeration values to strings.
//
// The reason for both the string view and the C string is because we often
// need a NUL-terminated string, but string views are not guaranteed to be
// NUL-termiated. Yet strings views are *much* more useful, and generating
// them at runtime from the C string has a cost.
//
// So... we get both: a pointer to a NUL-terminated static char array, and a
// string view of that.
//
// A default mapping is generated just using the enumerator identifiers.
// Otherwise, a manual mapping can be generated using
// `generate_enumeration_string_map()`, with or without the enumerator
// identifiers, and any other strings you like.
//
// TODO: EDG hasn't added `define_static_string()` yet. We could polyfill
// it... but meh. It'll be added sooner rather than later, so we'll just wait.
// In the meantime, the C string pointer is just `nullptr`.
template<enumeration E>
struct enumeration_string_mapping_type
{
    E value;
    char const* c_str;
    std::string_view string;

consteval explicit enumeration_string_mapping_type()
        : value{}
        , c_str{}
        , string{}
    {}

consteval explicit enumeration_string_mapping_type(E v, std::string_view sv)
        : value{v}
        // TODO: When we get define_static_string(), the next two lines will
        // be:
        //      , c_str{std::meta::define_static_string(sv)}
        //      , string{c_str}
        , c_str{nullptr}
        , string{sv}
    {}

consteval explicit enumeration_string_mapping_type(std::meta::info i)
        : value{extract<E>(i)}
        // TODO: When we get define_static_string(), the next two lines will
        // be:
        //      , c_str{std::meta::define_static_string(identifier_of(i))}
        //      , string{c_str}
        , c_str{nullptr}
        , string{identifier_of(i)}
    {}
};

template<enumeration E>
consteval auto default_enumeration_string_map()
{
    auto result = std::array<enumeration_string_mapping_type<E>, enumerators_of(^E).size()>{};
    std::ranges::transform(
        enumerators_of(^E),
        std::ranges::begin(result),
        [](std::meta::info i) { return enumeration_string_mapping_type<E>{i}; }
    );

return result;
}

template<enumeration E>
inline constexpr auto enumeration_string_map = default_enumeration_string_map<E>();

//////////////////////////////////////////////////////////////////////////////
// generate_enumeration_string_map<bool>(Args&&...);
//
// Overrides the default `enumeration_string_map<E>` for an enumeration.
//
// If the mandatory `bool` template parameter is true, the enumerator's
// identifiers are used first. Otherwise, they are not included.
//
// The function arguments are groups of enumeration values and strings (that
// is, anything convertible to `std::string_view`). Each group starts with an
// enumeration value. The following strings in the group are all mapped to
// that value.
//
// If the same string is used multiple times, then:
//  *   If it is used for the same enumeration value, it is ignored.
//  *   If it is used for a different enumeration value, an error is raised.
//
// Examples:
//      ```
//      enum class foo { bar, baz };
//      generate_enumeration_string_map<true>();
//      // indi::enumeration_string_map<foo> maps:
//      //      foo::bar : "bar"
//      //      foo::baz : "baz"
//      // same as default generated map
//      ```
//
//      ```
//      enum class the_type{ x, y, z };
//      generate_enumeration_string_map<false>();
//      // indi::enumeration_string_map<foo> maps:
//      //      <nothing>
//      // which means the enumeration will always be converted to a string
//      // like "the_type{1}".
//      ```
//
// TODO: Verify map hasn't already been generated.
template<bool IncludeEnumerators = true, enumeration E, typename... Args>
requires ((std::same_as<Args, E> or std::convertible_to<Args, std::string_view>) and ...)
consteval auto generate_enumeration_string_map(E e, Args&&... args)
{
    auto map = std::array<
        enumeration_string_mapping_type<E>,
        (IncludeEnumerators ? enumerators_of(^E).size() : 0uz) + (0uz + ... + (not std::same_as<Args, E>))
    >{};

auto p = std::ranges::begin(map);

if constexpr (IncludeEnumerators)
    {
        p = std::ranges::transform(
            enumerators_of(^E),
            p,
            [](std::meta::info i) { return enumeration_string_mapping_type<E>{i}; }
        ).out;
    }

auto const process_arg = [&e, &map, &p](auto&& arg)
    {
        if constexpr (std::same_as<std::remove_cvref_t<decltype(arg)>, E>)
        {
            e = arg;
        }
        else
        {
            if (auto const i = std::ranges::find(std::ranges::begin(map), p, arg, &enumeration_string_mapping_type<E>::string); i != p)
            {
                if (i->value != e)
                    throw std::logic_error{std::string{"string is mapped to multiple enumerators: "} + arg};
            }
            else
            {
                *p++ = enumeration_string_mapping_type<E>{e, arg};
            }
        }
    };
    (..., process_arg(args));

auto tokens = ^{};
    std::ranges::for_each(std::ranges::begin(map), p, [&tokens](auto&& m){
        tokens = ^{\tokens(tokens) \(m),};
    });

tokens = ^{
        template<>
        inline constexpr auto enumeration_string_map<typename [:\(^E):]> =
            std::array{\tokens(tokens)};
    };

namespace_inject(^::indi, tokens);
}

template<bool IncludeEnumerators = true, enumeration E>
consteval auto generate_enumeration_string_map()
{
    auto tokens = ^{};

if constexpr (IncludeEnumerators)
        tokens = ^{ \(default_enumeration_string_map<typename [:\(^E):]>()) };
    else
        tokens = ^{ std::array<enumeration_string_mapping_type<typename [:\(^E):]>, 0>{} };

tokens = ^{
        template<>
        inline constexpr auto enumeration_string_map<typename [:\(^E):]> = tokens(tokens);
    };

namespace_inject(^::indi, tokens);
}

//////////////////////////////////////////////////////////////////////////////
template<enumeration E>
consteval auto generate_enumeration_stream_inserter()
{
    auto const enum_ns = parent_of(^E);

auto const tokens = ^{
        template<typename Char, typename Traits>
        auto operator<<(std::basic_ostream<Char, Traits>& o, typename [:\(^E):] e) -> std::basic_ostream<Char, Traits>&
        {
            if (o)
            {
                using type = decltype(e);
                using mapping_type = indi::enumeration_string_mapping_type<type>;

auto const& map = indi::enumeration_string_map<type>;
                if (auto const p = std::ranges::find(map, e, &mapping_type::value); p != std::ranges::end(map))
                {
                    // Not the most efficient implementation; can definitely be improved.
                    auto str = std::string{p->string};
                    o << str.c_str();
                }
                else
                {
                    // Not the most efficient implementation; can definitely be improved.
                    auto oss = std::ostringstream{};
                    oss.imbue(std::locale::classic());
                    oss << identifier_of(^type) <<  '{' << std::underlying_type_t<type>(e) << '}';

o << std::move(oss).str().c_str();
                }
            }

return o;
        }
    };

namespace_inject(enum_ns, tokens);
}

//////////////////////////////////////////////////////////////////////////////
template<enumeration E>
consteval auto generate_enumeration_stream_extractor()
{
    auto const enum_ns = parent_of(^E);

auto const tokens = ^{
        template<typename Char, typename Traits>
        auto operator>>(std::basic_istream<Char, Traits>& i, typename [:\(^E):]& e) -> std::basic_istream<Char, Traits>&
        {
            auto s = std::basic_string<Char, Traits>{};
            if (i >> s)
            {
                auto const& loc = i.getloc();
                auto const& ct = std::use_facet<std::ctype<Char>>(loc);
                std::ranges::transform(s, std::ranges::begin(s), [&loc](auto c) { return std::tolower(c, loc); });

using type = decltype(e);
                using mapping_type = indi::enumeration_string_mapping_type<typename [:\(^E):]>;

auto const& map = indi::enumeration_string_map<typename [:\(^E):]>;
                if (auto const p = std::ranges::find(map, s, [&loc, &ct](auto&& m) { auto s = std::basic_string<Char, Traits>{}; for (auto c : m.string) s.push_back(std::tolower(ct.widen(c), loc)); return s; }); p != std::ranges::end(map))
                    e = p->value;
                else
                    i.setstate(std::ios_base::failbit);
            }

return i;
        }
    };

namespace_inject(enum_ns, tokens);
}

//////////////////////////////////////////////////////////////////////////////
struct ParseError : std::runtime_error
{
    using std::runtime_error::runtime_error;
};

template<enumeration E>
struct enumeration_parse_error : ParseError
{
    explicit enumeration_parse_error(std::string_view s)
        : ParseError{"invalid string for `` enumeration: \"" + std::string{s} + "\""}
    {}
};

template<enumeration E>
auto Parse(std::string_view sv)
{
    auto s = std::string{sv};
    std::ranges::transform(s, std::ranges::begin(s), [](auto c) { return std::tolower(c, std::locale::classic()); });

if (auto const p = std::ranges::find(indi::enumeration_string_map<E>, s, [](auto&& m) { auto s = std::string{m.string}; std::ranges::transform(s, std::ranges::begin(s), [](auto c) { return std::tolower(c, std::locale::classic()); }); return s; }); p != std::ranges::end(indi::enumeration_string_map<E>))
        return p->value;
    else
        throw enumeration_parse_error<E>{sv};
}

//////////////////////////////////////////////////////////////////////////////
// TODO: Verify strings mapping hasn't already been defined.
template<bool IncludeEnumerators, enumeration E, typename... Args>
requires ((std::same_as<Args, E> or std::convertible_to<Args, std::string_view>) and ...)
consteval auto define_enum_strings_impl(E e, Args&&... args)
{
    generate_enumeration_string_map<IncludeEnumerators, E>(e, std::forward<Args>(args)...);

generate_enumeration_stream_inserter<E>();
    generate_enumeration_stream_extractor<E>();
}

struct without_default_enumerators_t
{
    constexpr explicit without_default_enumerators_t() noexcept = default;
};

inline constexpr auto without_default_enumerators = without_default_enumerators_t{};

template<enumeration E, typename... Args>
requires ((std::same_as<Args, E> or std::convertible_to<Args, std::string_view>) and ...)
consteval auto DefineEnumStrings(without_default_enumerators_t, E e, Args&&... args)
{
    return define_enum_strings_impl<false>(e, std::forward<Args>(args)...);
}

template<enumeration E, typename... Args>
requires ((std::same_as<Args, E> or std::convertible_to<Args, std::string_view>) and ...)
consteval auto DefineEnumStrings(E e, Args&&... args)
{
    return define_enum_strings_impl<true>(e, std::forward<Args>(args)...);
}

template<enumeration E>
inline constexpr auto enumerate = std::invoke([]{
    auto map = std::array<std::string_view, enumerators_of(^E).size()>{};
    std::ranges::transform(
        enumerators_of(^E),
        std::ranges::begin(map),
        [](std::meta::info i) { return identifier_of(i); }
    );

return map;
});

} // namespace indi

// Here's the sample enum to demonstrate.
//
// (Doesn't need to be in a custom namespace, but I put it in one just to show
// it works.)
namespace ns {

enum class Days {
Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday
};

consteval {
// Don't need braces around each pair anymore.
//
// And if you wanted to, you could write:
// Days::Monday, "Monday", "Mon", "M", "whatevs",
// Days::Tuesday, "Tuesday", "Tue", "T", "whatevs",
// ...
//
// *AND* you don't need to specify the strings that are the same as the
// enumerator. They get added automatically, though you can opt out by
// calling:
//  *   indi::DefineEnumStrings(
//          indi::without_default_enumerators,
//          Days::Monday, "Mon", ...);
//
// **AND** error checking is done, to catch if you duplicated a string.
indi::DefineEnumStrings( // Days, // Don't need this unnecessary repetition.
    //Days::Monday, "Monday",
    //Days::Tuesday, "Tuesday",
    //Days::Wednesday, "Wednesday",
    //Days::Thursday, "Thursday",
    //Days::Friday, "Friday",
    //Days::Saturday, "Saturday",
    //Days::Sunday, "Sunday",
    Days::Monday, "Mon"
    //...
);
} // consteval

} // namespace ns

auto main() -> int
{
    std::cout << "Days::Monday = " << ns::Days::Monday << '\n';
    std::cout << "Days{420}    = " << ns::Days{420} << '\n';
    std::cout << '\n';

auto day = ns::Days{};
    std::cin>>day; //user enters "mon"
    std::cout<<"Today is "<<day<<std::endl; //output will be "Today is Monday"
    // std::getline(cin, day); //this is also possible // THIS IS A TERRIBLE IDEA! No. Just... no.

try {
        indi::Parse<ns::Days>("not valid");
    }
    catch(const indi::ParseError &ex) {
        std::cout<<ex.what()<<std::endl;

std::cout<<"Days of week are: "<<std::endl;
        for(auto e : indi::enumerate<ns::Days>) {
            std::cout<<e<<std::endl;
        }
    }
}

// Not a macro in sight.
//
// And if you use modules, you won't even need that wall of includes.
// Just `import std;` and you're golden.
//
// I tried to match the original library as closely as possible
// (except for not supporting the `getline()` thing... which is
// just illegal and silly).
//
// However, this code is a bit shorter, yet does extensive
// error checking that the original code does not, and has quite a bit
// more features (like formatting unknown enumeration values).