example.x.cpp

#include "wise_enum.h"
#include "compact_optional.h"

#include <cassert>
#include <iostream>

// Equivalent to enum Color {GREEN = 2, RED};
namespace my_lib {
WISE_ENUM(Color, (GREEN, 2), RED)
}

// Equivalent to enum class MoreColor : int64_t {BLUE, BLACK = 1};
WISE_ENUM_CLASS((MoreColor, int64_t), BLUE, (BLACK, 1))

// Inside a class, must use a different macro, but still works
struct Bar {
  WISE_ENUM_MEMBER(Foo, BUZ)
};

// Adapt an existing enum you don't control so it works with generic code
namespace another_lib {
enum class SomebodyElse { FIRST, SECOND };
}
WISE_ENUM_ADAPT(another_lib::SomebodyElse, FIRST, SECOND)

int main() {

  // Number of enumerations:
  static_assert(wise_enum::size<my_lib::Color> == 2, "");
  std::cerr << "Number of enumerators: "
            << wise_enum::size<my_lib::Color> << "\n";

  // Iterate over enums
  std::cerr << "Enum values and names:\n";
  for (auto e : wise_enum::range<my_lib::Color>) {
    std::cerr << static_cast<int>(e.value) << " " << e.name << "\n";
  }
  std::cerr << "\n";

  // Convert any enum to a string
  std::cerr << wise_enum::to_string(my_lib::Color::RED) << "\n";

  // Convert any string to an optional enum
  auto x1 = wise_enum::from_string<my_lib::Color>("GREEN");
  auto x2 = wise_enum::from_string<my_lib::Color>("Greeeeeeen");

  assert(x1.value() == my_lib::Color::GREEN);
  assert(!x2);

  // Everything is constexpr, and a type trait is made available for easy use in
  // enable_if/tag dispatch
  static_assert(wise_enum::is_wise_enum_v<my_lib::Color>, "");
  static_assert(!wise_enum::is_wise_enum_v<int>, "");
  enum flub { blub, glub };
  static_assert(!wise_enum::is_wise_enum_v<flub>, "");
  // We made a regular enum wise!
  static_assert(wise_enum::is_wise_enum_v<another_lib::SomebodyElse>, "");

  // Assert underlying type
  static_assert(std::is_same<int64_t, std::underlying_type_t<MoreColor>>::value,
                "");

  // Full API available for adapted wise enums
  for (auto e : wise_enum::range<another_lib::SomebodyElse>) {
    std::cerr << static_cast<int>(e.value) << " "
              << wise_enum::to_string(e.value) << "\n";
  }

  // Compact optional demo
  wise_enum::compact_optional<my_lib::Color> o;
  assert(!o);
  assert(o.value_or(my_lib::Color::RED) == my_lib::Color::RED);
  o = my_lib::Color::GREEN;
  assert(o.value() == my_lib::Color::GREEN);
  o.reset();
  assert(!o);

  return 0;
}