pow_enum.hpp

Go to the documentation of this file.

#pragma once

#include <cstdlib>
#include <string>
#include <utility>

namespace reactions::pow_enum {

  template <char... C> struct string_tpl {
    static constexpr char chars[sizeof...(C) + 1] = {C..., '\0'};
  };

  template <typename lambda_str_type> struct string_builder {
    template <std::size_t... indices> struct produce {
      typedef string_tpl<lambda_str_type{}.chars[indices]...> result;
    };
  };

  template <std::size_t count, template <std::size_t...> class meta_functor,
            std::size_t... indices>
  struct apply_range {
    typedef typename apply_range<count - 1, meta_functor, count - 1,
                                 indices...>::result result;
  };

  template <template <std::size_t...> class meta_functor,
            std::size_t... indices>
  struct apply_range<0, meta_functor, indices...> {
    typedef typename meta_functor<indices...>::result result;
  };

  template <class... S> struct string_group {
    static constexpr const char *chars[sizeof...(S) + 1] = {S::chars...,
                                                            nullptr};
  };

  template <class... Strings, char... C>
  constexpr auto parse_string_impl(string_group<Strings...>, string_tpl<C...>,
                                   string_tpl<>) {
    return string_group<Strings..., string_tpl<C...>>{};
  }

  template <class... Strings, char... Cp, char C0, char... C>
  constexpr auto parse_string_impl(string_group<Strings...>, string_tpl<Cp...>,
                                   string_tpl<C0, C...>) {
    if constexpr (C0 == ' ' || C0 == '\t')
      return parse_string_impl(string_group<Strings...>{}, string_tpl<Cp...>{},
                               string_tpl<C...>{});
    else if constexpr (C0 == ',')
      return parse_string_impl(string_group<Strings..., string_tpl<Cp...>>{},
                               string_tpl<>{}, string_tpl<C...>{});
    else
      return parse_string_impl(string_group<Strings...>{},
                               string_tpl<Cp..., C0>{}, string_tpl<C...>{});
  }

  template <char... C> constexpr auto parse_string(string_tpl<C...> s) {
    return parse_string_impl(string_group<>{}, string_tpl<>{}, s);
  }
} // namespace reactions::pow_enum

#define REACTIONS_POW_ENUM(enum_name, ...)                                     \
  enum enum_name : int { __VA_ARGS__ };                                        \
                                                                               \
  struct enum_name##_properties {                                              \
                                                                               \
    static constexpr std::size_t size =                                        \
        std::initializer_list{__VA_ARGS__}.size();                             \
                                                                               \
    static constexpr enum_name list[size] = {__VA_ARGS__};                     \
                                                                               \
    template <enum_name E, std::size_t I = 0>                                  \
    static constexpr auto index_impl() {                                       \
      static_assert(I < size);                                                 \
      if constexpr (list[I] == E)                                              \
        return I;                                                              \
      else                                                                     \
        return index_impl<E, I + 1>();                                         \
    }                                                                          \
                                                                               \
    template <enum_name E> static constexpr auto index() {                     \
      return index_impl<E>();                                                  \
    }                                                                          \
  }
// must use a comma

#define REACTIONS_POW_ENUM_WITH_UNKNOWN(enum_name, ...)                        \
  enum enum_name : int { unknown_##enum_name = 0, __VA_ARGS__ };               \
                                                                               \
  struct enum_name##_properties {                                              \
                                                                               \
    static constexpr std::size_t size =                                        \
        std::initializer_list{__VA_ARGS__}.size();                             \
                                                                               \
    static constexpr enum_name list[size] = {__VA_ARGS__};                     \
                                                                               \
    template <enum_name E, std::size_t I = 0>                                  \
    static constexpr auto index_impl() {                                       \
      static_assert(I < size);                                                 \
      if constexpr (list[I] == E)                                              \
        return I;                                                              \
      else                                                                     \
        return index_impl<E, I + 1>();                                         \
    }                                                                          \
                                                                               \
    template <enum_name E> static constexpr auto index() {                     \
      return index_impl<E>();                                                  \
    }                                                                          \
                                                                               \
    static enum_name from_string(const char *s) {                              \
      auto i = 0u;                                                             \
      for (; i < size; ++i)                                                    \
        if (strcmp(                                                            \
                [] {                                                           \
                  struct constexpr_string_type {                               \
                    const char *chars = #__VA_ARGS__;                          \
                  };                                                           \
                  return reactions::pow_enum::parse_string(                    \
                      reactions::pow_enum::apply_range<                        \
                          sizeof(#__VA_ARGS__) - 1,                            \
                          reactions::pow_enum::string_builder<                 \
                              constexpr_string_type>::produce>::result{});     \
                }()                                                            \
                    .chars[i],                                                 \
                s) == 0)                                                       \
          return list[i];                                                      \
      return unknown_##enum_name;                                              \
    }                                                                          \
                                                                               \
    static enum_name from_string(std::string const &s) {                       \
      return from_string(s.c_str());                                           \
    }                                                                          \
                                                                               \
    static const char *to_c_string(enum_name e) {                              \
      auto i = 0u;                                                             \
      for (; i < size; ++i)                                                    \
        if (list[i] == e)                                                      \
          break;                                                               \
      return [] {                                                              \
        struct constexpr_string_type {                                         \
          const char *chars = #__VA_ARGS__;                                    \
        };                                                                     \
        return reactions::pow_enum::parse_string(                              \
            reactions::pow_enum::apply_range<                                  \
                sizeof(#__VA_ARGS__) - 1,                                      \
                reactions::pow_enum::string_builder<                           \
                    constexpr_string_type>::produce>::result{});               \
      }()                                                                      \
                 .chars[i];                                                    \
    }                                                                          \
    static std::string to_string(enum_name e) { return to_c_string(e); }       \
  }
// must use a comma