enums.h

Go to the documentation of this file.

#ifndef enums_h
#define enums_h
 
#include <algorithm>
#include <array>
#include <iostream>
#include <sstream>
#include <string>
#include <string_view>
 
#include "debug.h"
#include "nonstd.h"
 
template <typename EnumType> constexpr bool good_enum(EnumType x) noexcept {
  return std::size_t(x) < std::size_t(EnumType::FINAL);
}
 
template <typename EnumType>
constexpr std::array<std::string_view, size_t(EnumType::FINAL)>
enum_strarray(const std::string_view strchars) noexcept {
  std::array<std::string_view, size_t(EnumType::FINAL)> out;
 
  // Find the start
  std::string_view::size_type N0 = 0;
 
  // Set all the values
  for (auto &str : out) {
    // Find a comma but never look beyond the end of the string
    const std::string_view::size_type N1 =
        std::min(strchars.find(',', N0), strchars.size());
 
    // Set the string between start and the length of the string
    str = strchars.substr(N0, N1 - N0);
 
    // Remove spaces at the beginning and at the end of the string
    while (nonstd::isspace(str.front()))
      str.remove_prefix(1);
    while (nonstd::isspace(str.back()))
      str.remove_suffix(1);
 
    // Set the new start for the next iteration
    N0 = N1 + 1;
  }
 
  return out;
}
 
template <typename EnumType>
constexpr std::array<std::string_view, 0> enum_strarray() noexcept {
  return {};
}
 
template <typename EnumType>
constexpr std::array<EnumType, size_t(EnumType::FINAL)>
enum_typarray() noexcept {
  std::array<EnumType, size_t(EnumType::FINAL)> out{};
  for (size_t i = 0; i < size_t(EnumType::FINAL); i++)
    out[i] = EnumType(i);
  return out;
}
 
template <typename EnumType, typename... Messages>
constexpr void check_enum_error(EnumType type, Messages... args) {
  ARTS_USER_ERROR_IF(not good_enum(type), args...)
}
 
#define ENUMCLASS(ENUMTYPE, TYPE, ...)                                         \
  enum class ENUMTYPE : TYPE { __VA_OPT__(__VA_ARGS__, ) FINAL };              \
                                                                               \
  namespace enumstrs {                                                         \
  constexpr auto ENUMTYPE##Names =                                             \
      enum_strarray<ENUMTYPE>(__VA_OPT__(#__VA_ARGS__));                       \
  }                                                                            \
                                                                               \
  namespace enumtyps {                                                         \
  [[maybe_unused]] constexpr auto ENUMTYPE##Types = enum_typarray<ENUMTYPE>(); \
  }                                                                            \
                                                                               \
  constexpr std::string_view toString(ENUMTYPE x) noexcept {                   \
    if (good_enum(x))                                                          \
      return enumstrs::ENUMTYPE##Names[(TYPE)x];                               \
    return "BAD " #ENUMTYPE;                                                   \
  }                                                                            \
                                                                               \
  constexpr ENUMTYPE to##ENUMTYPE(const std::string_view x) noexcept {         \
    for (TYPE i = 0; i < (TYPE)ENUMTYPE::FINAL; i++)                           \
      if (enumstrs::ENUMTYPE##Names[i] == x)                                   \
        return ENUMTYPE(i);                                                    \
    return ENUMTYPE::FINAL;                                                    \
  }                                                                            \
                                                                               \
  constexpr ENUMTYPE to##ENUMTYPE##OrThrow(const std::string_view x) {         \
    const ENUMTYPE out = to##ENUMTYPE(x);                                      \
    check_enum_error(out, "Cannot understand argument: \"", x,                 \
                     "\"\n"                                                    \
                     "Valid " #ENUMTYPE                                        \
                     " options are: [" __VA_OPT__(#__VA_ARGS__) "]");          \
    return out;                                                                \
  }                                                                            \
                                                                               \
  inline std::ostream &operator<<(std::ostream &os, const ENUMTYPE x) {        \
    return os << toString(x);                                                  \
  }                                                                            \
                                                                               \
  inline std::istream &operator>>(std::istream &is, ENUMTYPE &x) {             \
    std::string val;                                                           \
    is >> val;                                                                 \
    x = to##ENUMTYPE##OrThrow(val);                                            \
    return is;                                                                 \
  }
 
#endif // enums_h