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<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_ARGS__, FINAL };                      \
                                                                          \
  namespace enumstrs {                                                    \
  constexpr auto ENUMTYPE##Names = enum_strarray<ENUMTYPE>(#__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) {    \
    ENUMTYPE out = to##ENUMTYPE(x);                                       \
    check_enum_error(out, "Cannot understand argument: \"", x, "\"\n"     \
                     "Valid " #ENUMTYPE " options are: ["                 \
                     #__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