enum_values.hpp

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <cstddef>
#include <limits>
#include <optional>
#include <string_view>
#include <type_traits>
 
namespace algotradelib {


namespace enum_values_detail {
 
// A scoped enum (`enum class`) always has a fixed underlying type, so every value of that type is a value of
// the enum and the conversions below are defined. An unscoped one converts to an integer implicitly.
template <typename Enum, bool = std::is_enum<Enum>::value>
struct is_scoped_enum : std::false_type {};
 
template <typename Enum>
struct is_scoped_enum<Enum, true>
: std::integral_constant<bool, !std::is_convertible<Enum, std::underlying_type_t<Enum>>::value> {};
 
template <typename Enum, typename IsEnumerator>
constexpr bool lists_every_value(const Enum* values, std::size_t count, IsEnumerator is_enumerator) noexcept {
  using Underlying = std::underlying_type_t<Enum>;
  for (std::size_t index = 0; index < count; ++index) {
    const auto value = static_cast<Underlying>(values[index]);
    if constexpr (std::is_signed<Underlying>::value) {
      if (value < 0) {
        return false;
      }
    }
    if (static_cast<std::size_t>(value) >= count || !is_enumerator(values[index])) {
      return false;
    }
    for (std::size_t other = 0; other < index; ++other) {
      if (values[other] == values[index]) {
        return false;
      }
    }
  }
  // `count` distinct values below `count` that fill the underlying type leave nothing beyond them, and
  // converting `count` would wrap onto 0 (an `enum class : bool` with both values listed).
  if (count > static_cast<std::size_t>(std::numeric_limits<Underlying>::max())) {
    return true;
  }
  return !is_enumerator(static_cast<Enum>(static_cast<Underlying>(count)));
}
 
} // namespace enum_values_detail

template <typename Enum, std::size_t N, typename IsEnumerator>
constexpr bool lists_every_value(const std::array<Enum, N>& values, IsEnumerator is_enumerator) noexcept {
  static_assert(
    enum_values_detail::is_scoped_enum<Enum>::value,
    "lists_every_value checks a list of a scoped enum's values (enum class)"
  );
  return enum_values_detail::lists_every_value(values.data(), N, is_enumerator);
}

template <typename Enum, std::size_t N, typename IsEnumerator>
constexpr bool lists_every_value(const Enum (&values)[N], IsEnumerator is_enumerator) noexcept {
  static_assert(
    enum_values_detail::is_scoped_enum<Enum>::value,
    "lists_every_value checks a list of a scoped enum's values (enum class)"
  );
  return enum_values_detail::lists_every_value(values, N, is_enumerator);
}

template <typename Enum, std::size_t N, typename Name>
constexpr std::optional<Enum> value_named(
  const std::array<Enum, N>& values,
  Name name,
  std::string_view text
) noexcept {
  if (text.empty()) {
    return std::nullopt;
  }
  for (const auto value : values) {
    if (name(value) == text) {
      return value;
    }
  }
  return std::nullopt;
}
 
} // namespace algotradelib