|
|
// This file is part of Better Enums, released under the BSD 2-clause license.
// See LICENSE.md for details, or visit http://github.com/aantron/better-enums.
#pragma once
#ifndef BETTER_ENUMS_ENUM_H
#define BETTER_ENUMS_ENUM_H
#include <cstddef>
#include <cstring>
#include <iosfwd>
#include <stdexcept>
// in-line, non-#pragma warning handling
// not supported in very old compilers (namely gcc 4.4 or less)
#ifdef __GNUC__
# ifdef __clang__
# define BETTER_ENUMS_IGNORE_OLD_CAST_HEADER _Pragma("clang diagnostic push")
# define BETTER_ENUMS_IGNORE_OLD_CAST_BEGIN _Pragma("clang diagnostic ignored \"-Wold-style-cast\"")
# define BETTER_ENUMS_IGNORE_OLD_CAST_END _Pragma("clang diagnostic pop")
# define BETTER_ENUMS_IGNORE_ATTRIBUTES_HEADER
# define BETTER_ENUMS_IGNORE_ATTRIBUTES_BEGIN
# define BETTER_ENUMS_IGNORE_ATTRIBUTES_END
# else
# define BETTER_ENUMS_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100)
# if BETTER_ENUMS_GCC_VERSION > 40400
# define BETTER_ENUMS_IGNORE_OLD_CAST_HEADER _Pragma("GCC diagnostic push")
# define BETTER_ENUMS_IGNORE_OLD_CAST_BEGIN _Pragma("GCC diagnostic ignored \"-Wold-style-cast\"")
# define BETTER_ENUMS_IGNORE_OLD_CAST_END _Pragma("GCC diagnostic pop")
# if (BETTER_ENUMS_GCC_VERSION >= 70300)
# define BETTER_ENUMS_IGNORE_ATTRIBUTES_HEADER _Pragma("GCC diagnostic push")
# define BETTER_ENUMS_IGNORE_ATTRIBUTES_BEGIN _Pragma("GCC diagnostic ignored \"-Wattributes\"")
# define BETTER_ENUMS_IGNORE_ATTRIBUTES_END _Pragma("GCC diagnostic pop")
# else
# define BETTER_ENUMS_IGNORE_ATTRIBUTES_HEADER
# define BETTER_ENUMS_IGNORE_ATTRIBUTES_BEGIN
# define BETTER_ENUMS_IGNORE_ATTRIBUTES_END
# endif
# else
# define BETTER_ENUMS_IGNORE_OLD_CAST_HEADER
# define BETTER_ENUMS_IGNORE_OLD_CAST_BEGIN
# define BETTER_ENUMS_IGNORE_OLD_CAST_END
# define BETTER_ENUMS_IGNORE_ATTRIBUTES_HEADER
# define BETTER_ENUMS_IGNORE_ATTRIBUTES_BEGIN
# define BETTER_ENUMS_IGNORE_ATTRIBUTES_END
# endif
# endif
#else // empty definitions for compilers that don't support _Pragma
# define BETTER_ENUMS_IGNORE_OLD_CAST_HEADER
# define BETTER_ENUMS_IGNORE_OLD_CAST_BEGIN
# define BETTER_ENUMS_IGNORE_OLD_CAST_END
# define BETTER_ENUMS_IGNORE_ATTRIBUTES_HEADER
# define BETTER_ENUMS_IGNORE_ATTRIBUTES_BEGIN
# define BETTER_ENUMS_IGNORE_ATTRIBUTES_END
#endif
// Feature detection.
#ifdef __GNUC__
# ifdef __clang__
# if __has_feature(cxx_constexpr)
# define BETTER_ENUMS_HAVE_CONSTEXPR
# endif
# if !defined(__EXCEPTIONS) || !__has_feature(cxx_exceptions)
# define BETTER_ENUMS_NO_EXCEPTIONS
# endif
# else
# if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L
# if (__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6))
# define BETTER_ENUMS_HAVE_CONSTEXPR
# endif
# endif
# ifndef __EXCEPTIONS
# define BETTER_ENUMS_NO_EXCEPTIONS
# endif
# endif
#endif
#ifdef _MSC_VER
# if _MSC_VER >= 1911
# define BETTER_ENUMS_HAVE_CONSTEXPR
# endif
# ifdef __clang__
# if __has_feature(cxx_constexpr)
# define BETTER_ENUMS_HAVE_CONSTEXPR
# endif
# endif
# ifndef _CPPUNWIND
# define BETTER_ENUMS_NO_EXCEPTIONS
# endif
# if _MSC_VER < 1600
# define BETTER_ENUMS_VC2008_WORKAROUNDS
# endif
#endif
#ifdef BETTER_ENUMS_CONSTEXPR
# define BETTER_ENUMS_HAVE_CONSTEXPR
#endif
#ifdef BETTER_ENUMS_NO_CONSTEXPR
# ifdef BETTER_ENUMS_HAVE_CONSTEXPR
# undef BETTER_ENUMS_HAVE_CONSTEXPR
# endif
#endif
// GCC (and maybe clang) can be made to warn about using 0 or NULL when nullptr
// is available, so Better Enums tries to use nullptr. This passage uses
// availability of constexpr as a proxy for availability of nullptr, i.e. it
// assumes that nullptr is available when compiling on the right versions of gcc
// and clang with the right -std flag. This is actually slightly wrong, because
// nullptr is also available in Visual C++, but constexpr isn't. This
// imprecision doesn't matter, however, because VC++ doesn't have the warnings
// that make using nullptr necessary.
#ifdef BETTER_ENUMS_HAVE_CONSTEXPR
# define BETTER_ENUMS_CONSTEXPR_ constexpr
# define BETTER_ENUMS_NULLPTR nullptr
#else
# define BETTER_ENUMS_CONSTEXPR_
# define BETTER_ENUMS_NULLPTR NULL
#endif
#ifndef BETTER_ENUMS_NO_EXCEPTIONS
# define BETTER_ENUMS_IF_EXCEPTIONS(x) x
#else
# define BETTER_ENUMS_IF_EXCEPTIONS(x)
#endif
#ifdef __GNUC__
# define BETTER_ENUMS_UNUSED __attribute__((__unused__))
#else
# define BETTER_ENUMS_UNUSED
#endif
// Higher-order preprocessor macros.
#ifdef BETTER_ENUMS_MACRO_FILE
# include BETTER_ENUMS_MACRO_FILE
#else
#define BETTER_ENUMS_PP_MAP(macro, data, ...) \
BETTER_ENUMS_ID( \ BETTER_ENUMS_APPLY( \ BETTER_ENUMS_PP_MAP_VAR_COUNT, \ BETTER_ENUMS_PP_COUNT(__VA_ARGS__)) \ (macro, data, __VA_ARGS__))
#define BETTER_ENUMS_PP_MAP_VAR_COUNT(count) BETTER_ENUMS_M ## count
#define BETTER_ENUMS_APPLY(macro, ...) BETTER_ENUMS_ID(macro(__VA_ARGS__))
#define BETTER_ENUMS_ID(x) x
#define BETTER_ENUMS_M1(m, d, x) m(d,0,x)
#define BETTER_ENUMS_M2(m,d,x,...) m(d,1,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M1(m,d,__VA_ARGS__))#define BETTER_ENUMS_M3(m,d,x,...) m(d,2,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M2(m,d,__VA_ARGS__))#define BETTER_ENUMS_M4(m,d,x,...) m(d,3,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M3(m,d,__VA_ARGS__))#define BETTER_ENUMS_M5(m,d,x,...) m(d,4,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M4(m,d,__VA_ARGS__))#define BETTER_ENUMS_M6(m,d,x,...) m(d,5,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M5(m,d,__VA_ARGS__))#define BETTER_ENUMS_M7(m,d,x,...) m(d,6,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M6(m,d,__VA_ARGS__))#define BETTER_ENUMS_M8(m,d,x,...) m(d,7,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M7(m,d,__VA_ARGS__))#define BETTER_ENUMS_M9(m,d,x,...) m(d,8,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M8(m,d,__VA_ARGS__))#define BETTER_ENUMS_M10(m,d,x,...) m(d,9,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M9(m,d,__VA_ARGS__))#define BETTER_ENUMS_M11(m,d,x,...) m(d,10,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M10(m,d,__VA_ARGS__))#define BETTER_ENUMS_M12(m,d,x,...) m(d,11,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M11(m,d,__VA_ARGS__))#define BETTER_ENUMS_M13(m,d,x,...) m(d,12,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M12(m,d,__VA_ARGS__))#define BETTER_ENUMS_M14(m,d,x,...) m(d,13,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M13(m,d,__VA_ARGS__))#define BETTER_ENUMS_M15(m,d,x,...) m(d,14,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M14(m,d,__VA_ARGS__))#define BETTER_ENUMS_M16(m,d,x,...) m(d,15,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M15(m,d,__VA_ARGS__))#define BETTER_ENUMS_M17(m,d,x,...) m(d,16,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M16(m,d,__VA_ARGS__))#define BETTER_ENUMS_M18(m,d,x,...) m(d,17,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M17(m,d,__VA_ARGS__))#define BETTER_ENUMS_M19(m,d,x,...) m(d,18,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M18(m,d,__VA_ARGS__))#define BETTER_ENUMS_M20(m,d,x,...) m(d,19,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M19(m,d,__VA_ARGS__))#define BETTER_ENUMS_M21(m,d,x,...) m(d,20,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M20(m,d,__VA_ARGS__))#define BETTER_ENUMS_M22(m,d,x,...) m(d,21,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M21(m,d,__VA_ARGS__))#define BETTER_ENUMS_M23(m,d,x,...) m(d,22,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M22(m,d,__VA_ARGS__))#define BETTER_ENUMS_M24(m,d,x,...) m(d,23,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M23(m,d,__VA_ARGS__))#define BETTER_ENUMS_M25(m,d,x,...) m(d,24,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M24(m,d,__VA_ARGS__))#define BETTER_ENUMS_M26(m,d,x,...) m(d,25,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M25(m,d,__VA_ARGS__))#define BETTER_ENUMS_M27(m,d,x,...) m(d,26,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M26(m,d,__VA_ARGS__))#define BETTER_ENUMS_M28(m,d,x,...) m(d,27,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M27(m,d,__VA_ARGS__))#define BETTER_ENUMS_M29(m,d,x,...) m(d,28,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M28(m,d,__VA_ARGS__))#define BETTER_ENUMS_M30(m,d,x,...) m(d,29,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M29(m,d,__VA_ARGS__))#define BETTER_ENUMS_M31(m,d,x,...) m(d,30,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M30(m,d,__VA_ARGS__))#define BETTER_ENUMS_M32(m,d,x,...) m(d,31,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M31(m,d,__VA_ARGS__))#define BETTER_ENUMS_M33(m,d,x,...) m(d,32,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M32(m,d,__VA_ARGS__))#define BETTER_ENUMS_M34(m,d,x,...) m(d,33,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M33(m,d,__VA_ARGS__))#define BETTER_ENUMS_M35(m,d,x,...) m(d,34,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M34(m,d,__VA_ARGS__))#define BETTER_ENUMS_M36(m,d,x,...) m(d,35,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M35(m,d,__VA_ARGS__))#define BETTER_ENUMS_M37(m,d,x,...) m(d,36,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M36(m,d,__VA_ARGS__))#define BETTER_ENUMS_M38(m,d,x,...) m(d,37,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M37(m,d,__VA_ARGS__))#define BETTER_ENUMS_M39(m,d,x,...) m(d,38,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M38(m,d,__VA_ARGS__))#define BETTER_ENUMS_M40(m,d,x,...) m(d,39,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M39(m,d,__VA_ARGS__))#define BETTER_ENUMS_M41(m,d,x,...) m(d,40,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M40(m,d,__VA_ARGS__))#define BETTER_ENUMS_M42(m,d,x,...) m(d,41,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M41(m,d,__VA_ARGS__))#define BETTER_ENUMS_M43(m,d,x,...) m(d,42,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M42(m,d,__VA_ARGS__))#define BETTER_ENUMS_M44(m,d,x,...) m(d,43,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M43(m,d,__VA_ARGS__))#define BETTER_ENUMS_M45(m,d,x,...) m(d,44,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M44(m,d,__VA_ARGS__))#define BETTER_ENUMS_M46(m,d,x,...) m(d,45,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M45(m,d,__VA_ARGS__))#define BETTER_ENUMS_M47(m,d,x,...) m(d,46,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M46(m,d,__VA_ARGS__))#define BETTER_ENUMS_M48(m,d,x,...) m(d,47,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M47(m,d,__VA_ARGS__))#define BETTER_ENUMS_M49(m,d,x,...) m(d,48,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M48(m,d,__VA_ARGS__))#define BETTER_ENUMS_M50(m,d,x,...) m(d,49,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M49(m,d,__VA_ARGS__))#define BETTER_ENUMS_M51(m,d,x,...) m(d,50,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M50(m,d,__VA_ARGS__))#define BETTER_ENUMS_M52(m,d,x,...) m(d,51,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M51(m,d,__VA_ARGS__))#define BETTER_ENUMS_M53(m,d,x,...) m(d,52,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M52(m,d,__VA_ARGS__))#define BETTER_ENUMS_M54(m,d,x,...) m(d,53,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M53(m,d,__VA_ARGS__))#define BETTER_ENUMS_M55(m,d,x,...) m(d,54,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M54(m,d,__VA_ARGS__))#define BETTER_ENUMS_M56(m,d,x,...) m(d,55,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M55(m,d,__VA_ARGS__))#define BETTER_ENUMS_M57(m,d,x,...) m(d,56,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M56(m,d,__VA_ARGS__))#define BETTER_ENUMS_M58(m,d,x,...) m(d,57,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M57(m,d,__VA_ARGS__))#define BETTER_ENUMS_M59(m,d,x,...) m(d,58,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M58(m,d,__VA_ARGS__))#define BETTER_ENUMS_M60(m,d,x,...) m(d,59,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M59(m,d,__VA_ARGS__))#define BETTER_ENUMS_M61(m,d,x,...) m(d,60,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M60(m,d,__VA_ARGS__))#define BETTER_ENUMS_M62(m,d,x,...) m(d,61,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M61(m,d,__VA_ARGS__))#define BETTER_ENUMS_M63(m,d,x,...) m(d,62,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M62(m,d,__VA_ARGS__))#define BETTER_ENUMS_M64(m,d,x,...) m(d,63,x) \
BETTER_ENUMS_ID(BETTER_ENUMS_M63(m,d,__VA_ARGS__))
#define BETTER_ENUMS_PP_COUNT_IMPL(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
_11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, \ _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, \ _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, \ _56, _57, _58, _59, _60, _61, _62, _63, _64, count, ...) count
#define BETTER_ENUMS_PP_COUNT(...) \
BETTER_ENUMS_ID(BETTER_ENUMS_PP_COUNT_IMPL(__VA_ARGS__, 64, 63, 62, 61, 60,\ 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42,\ 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24,\ 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, \ 4, 3, 2, 1))
#define BETTER_ENUMS_ITERATE(X, f, l) X(f, l, 0) X(f, l, 1) X(f, l, 2) \
X(f, l, 3) X(f, l, 4) X(f, l, 5) X(f, l, 6) X(f, l, 7) X(f, l, 8) \ X(f, l, 9) X(f, l, 10) X(f, l, 11) X(f, l, 12) X(f, l, 13) X(f, l, 14) \ X(f, l, 15) X(f, l, 16) X(f, l, 17) X(f, l, 18) X(f, l, 19) X(f, l, 20) \ X(f, l, 21) X(f, l, 22) X(f, l, 23)
#endif // #ifdef BETTER_ENUMS_MACRO_FILE else case
namespace better_enums {
// Optional type.
template <typename T>BETTER_ENUMS_CONSTEXPR_ inline T _default(){ return static_cast<typename T::_enumerated>(0);}
template <>BETTER_ENUMS_CONSTEXPR_ inline const char* _default<const char*>(){ return BETTER_ENUMS_NULLPTR;}
template <>BETTER_ENUMS_CONSTEXPR_ inline std::size_t _default<std::size_t>(){ return 0;}
template <typename T>struct optional { BETTER_ENUMS_CONSTEXPR_ optional() : _valid(false), _value(_default<T>()) { }
BETTER_ENUMS_CONSTEXPR_ optional(T v) : _valid(true), _value(v) { }
BETTER_ENUMS_CONSTEXPR_ const T& operator *() const { return _value; } BETTER_ENUMS_CONSTEXPR_ const T* operator ->() const { return &_value; }
BETTER_ENUMS_CONSTEXPR_ operator bool() const { return _valid; }
BETTER_ENUMS_CONSTEXPR_ const T& value() const { return _value; }
private: bool _valid; T _value;};
template <typename CastTo, typename Element>BETTER_ENUMS_CONSTEXPR_ static optional<CastTo>_map_index(const Element *array, optional<std::size_t> index){ return index ? static_cast<CastTo>(array[*index]) : optional<CastTo>();}
#ifdef BETTER_ENUMS_VC2008_WORKAROUNDS
#define BETTER_ENUMS_OR_THROW \
if (!maybe) \ throw std::runtime_error(message); \ \ return *maybe;
#else
#define BETTER_ENUMS_OR_THROW \
return maybe ? *maybe : throw std::runtime_error(message);
#endif
BETTER_ENUMS_IF_EXCEPTIONS(template <typename T>BETTER_ENUMS_CONSTEXPR_ static T _or_throw(optional<T> maybe, const char *message){ BETTER_ENUMS_OR_THROW})
template <typename T>BETTER_ENUMS_CONSTEXPR_ static T* _or_null(optional<T*> maybe){ return maybe ? *maybe : BETTER_ENUMS_NULLPTR;}
template <typename T>BETTER_ENUMS_CONSTEXPR_ static T _or_zero(optional<T> maybe){ return maybe ? *maybe : T::_from_integral_unchecked(0);}
// Functional sequencing. This is essentially a comma operator wrapped in a
// constexpr function. g++ 4.7 doesn't "accept" integral constants in the second
// position for the comma operator, and emits an external symbol, which then
// causes a linking error.
template <typename T, typename U>BETTER_ENUMS_CONSTEXPR_ Ucontinue_with(T, U value) { return value; }
// Values array declaration helper.
//! Get intrinsic value of an (Enum::value) by taking advantage of
// C-conversion's parentheses priority
template <typename EnumType>struct _eat_assign { explicit BETTER_ENUMS_CONSTEXPR_ _eat_assign(EnumType value) : _value(value) { }
template <typename Any> BETTER_ENUMS_CONSTEXPR_ const _eat_assign& operator =(Any) const { return *this; }
BETTER_ENUMS_CONSTEXPR_ operator EnumType () const { return _value; }
private: EnumType _value;};
// Iterables.
template <typename Element>struct _iterable { typedef const Element* iterator;
BETTER_ENUMS_CONSTEXPR_ iterator begin() const { return iterator(_array); } BETTER_ENUMS_CONSTEXPR_ iterator end() const { return iterator(_array + _size); } BETTER_ENUMS_CONSTEXPR_ std::size_t size() const { return _size; } BETTER_ENUMS_CONSTEXPR_ const Element& operator [](std::size_t index) const { return _array[index]; }
BETTER_ENUMS_CONSTEXPR_ _iterable(const Element *array, std::size_t s) : _array(array), _size(s) { }
private: const Element * const _array; const std::size_t _size;};
// String routines.
BETTER_ENUMS_CONSTEXPR_ static const char *_name_enders = "= \t\n";
BETTER_ENUMS_CONSTEXPR_ inline bool _ends_name(char c, std::size_t index = 0){ return c == _name_enders[index] ? true : _name_enders[index] == '\0' ? false : _ends_name(c, index + 1);}
BETTER_ENUMS_CONSTEXPR_ inline bool _has_initializer(const char *s, std::size_t index = 0){ return s[index] == '\0' ? false : s[index] == '=' ? true : _has_initializer(s, index + 1);}
BETTER_ENUMS_CONSTEXPR_ inline std::size_t_constant_length(const char *s, std::size_t index = 0){ return _ends_name(s[index]) ? index : _constant_length(s, index + 1);}
BETTER_ENUMS_CONSTEXPR_ inline char_select(const char *from, std::size_t from_length, std::size_t index){ return index >= from_length ? '\0' : from[index];}
BETTER_ENUMS_CONSTEXPR_ inline char _to_lower_ascii(char c){ return c >= 0x41 && c <= 0x5A ? static_cast<char>(c + 0x20) : c;}
BETTER_ENUMS_CONSTEXPR_ inline bool _names_match(const char *stringizedName, const char *referenceName, std::size_t index = 0){ return _ends_name(stringizedName[index]) ? referenceName[index] == '\0' : referenceName[index] == '\0' ? false : stringizedName[index] != referenceName[index] ? false : _names_match(stringizedName, referenceName, index + 1);}
BETTER_ENUMS_CONSTEXPR_ inline bool_names_match_nocase(const char *stringizedName, const char *referenceName, std::size_t index = 0){ return _ends_name(stringizedName[index]) ? referenceName[index] == '\0' : referenceName[index] == '\0' ? false : _to_lower_ascii(stringizedName[index]) != _to_lower_ascii(referenceName[index]) ? false : _names_match_nocase(stringizedName, referenceName, index + 1);}
inline void _trim_names(const char * const *raw_names, const char **trimmed_names, char *storage, std::size_t count){ std::size_t offset = 0;
for (std::size_t index = 0; index < count; ++index) { trimmed_names[index] = storage + offset;
std::size_t trimmed_length = std::strcspn(raw_names[index], _name_enders); storage[offset + trimmed_length] = '\0';
std::size_t raw_length = std::strlen(raw_names[index]); offset += raw_length + 1; }}
// Eager initialization.
template <typename Enum>struct _initialize_at_program_start { _initialize_at_program_start() { Enum::initialize(); }};
} // namespace better_enums
// Array generation macros.
#define BETTER_ENUMS_EAT_ASSIGN_SINGLE(EnumType, index, expression) \
(EnumType)((::better_enums::_eat_assign<EnumType>)EnumType::expression),
#define BETTER_ENUMS_EAT_ASSIGN(EnumType, ...) \
BETTER_ENUMS_ID( \ BETTER_ENUMS_PP_MAP( \ BETTER_ENUMS_EAT_ASSIGN_SINGLE, EnumType, __VA_ARGS__))
#ifdef BETTER_ENUMS_HAVE_CONSTEXPR
#define BETTER_ENUMS_SELECT_SINGLE_CHARACTER(from, from_length, index) \
::better_enums::_select(from, from_length, index),
#define BETTER_ENUMS_SELECT_CHARACTERS(from, from_length) \
BETTER_ENUMS_ITERATE( \ BETTER_ENUMS_SELECT_SINGLE_CHARACTER, from, from_length)
#define BETTER_ENUMS_TRIM_SINGLE_STRING(ignored, index, expression) \
constexpr std::size_t _length_ ## index = \ ::better_enums::_constant_length(#expression); \constexpr const char _trimmed_ ## index [] = \ { BETTER_ENUMS_SELECT_CHARACTERS(#expression, _length_ ## index) }; \constexpr const char *_final_ ## index = \ ::better_enums::_has_initializer(#expression) ? \ _trimmed_ ## index : #expression;
#define BETTER_ENUMS_TRIM_STRINGS(...) \
BETTER_ENUMS_ID( \ BETTER_ENUMS_PP_MAP( \ BETTER_ENUMS_TRIM_SINGLE_STRING, ignored, __VA_ARGS__))
#define BETTER_ENUMS_REFER_TO_SINGLE_STRING(ignored, index, expression) \
_final_ ## index,
#define BETTER_ENUMS_REFER_TO_STRINGS(...) \
BETTER_ENUMS_ID( \ BETTER_ENUMS_PP_MAP( \ BETTER_ENUMS_REFER_TO_SINGLE_STRING, ignored, __VA_ARGS__))
#endif // #ifdef BETTER_ENUMS_HAVE_CONSTEXPR
#define BETTER_ENUMS_STRINGIZE_SINGLE(ignored, index, expression) #expression,
#define BETTER_ENUMS_STRINGIZE(...) \
BETTER_ENUMS_ID( \ BETTER_ENUMS_PP_MAP( \ BETTER_ENUMS_STRINGIZE_SINGLE, ignored, __VA_ARGS__))
#define BETTER_ENUMS_RESERVE_STORAGE_SINGLE(ignored, index, expression) \
#expression ","
#define BETTER_ENUMS_RESERVE_STORAGE(...) \
BETTER_ENUMS_ID( \ BETTER_ENUMS_PP_MAP( \ BETTER_ENUMS_RESERVE_STORAGE_SINGLE, ignored, __VA_ARGS__))
// The enums proper.
#define BETTER_ENUMS_NS(EnumType) better_enums_data_ ## EnumType
#ifdef BETTER_ENUMS_VC2008_WORKAROUNDS
#define BETTER_ENUMS_COPY_CONSTRUCTOR(Enum) \
BETTER_ENUMS_CONSTEXPR_ Enum(const Enum &other) : \ _value(other._value) { }
#else
#define BETTER_ENUMS_COPY_CONSTRUCTOR(Enum)
#endif
#ifndef BETTER_ENUMS_CLASS_ATTRIBUTE
# define BETTER_ENUMS_CLASS_ATTRIBUTE
#endif
#define BETTER_ENUMS_TYPE(SetUnderlyingType, SwitchType, GenerateSwitchType, \
GenerateStrings, ToStringConstexpr, \ DeclareInitialize, DefineInitialize, CallInitialize, \ Enum, Underlying, ...) \ \namespace better_enums_data_ ## Enum { \ \BETTER_ENUMS_ID(GenerateSwitchType(Underlying, __VA_ARGS__)) \ \} \ \class BETTER_ENUMS_CLASS_ATTRIBUTE Enum { \ private: \ typedef ::better_enums::optional<Enum> _optional; \ typedef ::better_enums::optional<std::size_t> _optional_index; \ \ public: \ typedef Underlying _integral; \ \ enum _enumerated SetUnderlyingType(Underlying) { __VA_ARGS__ }; \ \ BETTER_ENUMS_CONSTEXPR_ Enum(_enumerated value) : _value(value) { } \ \ BETTER_ENUMS_COPY_CONSTRUCTOR(Enum) \ \ BETTER_ENUMS_CONSTEXPR_ operator SwitchType(Enum)() const \ { \ return SwitchType(Enum)(_value); \ } \ \ BETTER_ENUMS_CONSTEXPR_ _integral _to_integral() const; \ BETTER_ENUMS_IF_EXCEPTIONS( \ BETTER_ENUMS_CONSTEXPR_ static Enum _from_integral(_integral value); \ ) \ BETTER_ENUMS_CONSTEXPR_ static Enum \ _from_integral_unchecked(_integral value); \ BETTER_ENUMS_CONSTEXPR_ static _optional \ _from_integral_nothrow(_integral value); \ \ BETTER_ENUMS_CONSTEXPR_ std::size_t _to_index() const; \ BETTER_ENUMS_IF_EXCEPTIONS( \ BETTER_ENUMS_CONSTEXPR_ static Enum _from_index(std::size_t index); \ ) \ BETTER_ENUMS_CONSTEXPR_ static Enum \ _from_index_unchecked(std::size_t index); \ BETTER_ENUMS_CONSTEXPR_ static _optional \ _from_index_nothrow(std::size_t index); \ \ ToStringConstexpr const char* _to_string() const; \ BETTER_ENUMS_IF_EXCEPTIONS( \ BETTER_ENUMS_CONSTEXPR_ static Enum _from_string(const char *name); \ ) \ BETTER_ENUMS_CONSTEXPR_ static _optional \ _from_string_nothrow(const char *name); \ \ BETTER_ENUMS_IF_EXCEPTIONS( \ BETTER_ENUMS_CONSTEXPR_ static Enum _from_string_nocase(const char *name); \ ) \ BETTER_ENUMS_CONSTEXPR_ static _optional \ _from_string_nocase_nothrow(const char *name); \ \ BETTER_ENUMS_CONSTEXPR_ static bool _is_valid(_integral value); \ BETTER_ENUMS_CONSTEXPR_ static bool _is_valid(const char *name); \ BETTER_ENUMS_CONSTEXPR_ static bool _is_valid_nocase(const char *name); \ \ typedef ::better_enums::_iterable<Enum> _value_iterable; \ typedef ::better_enums::_iterable<const char*> _name_iterable; \ \ typedef _value_iterable::iterator _value_iterator; \ typedef _name_iterable::iterator _name_iterator; \ \ BETTER_ENUMS_CONSTEXPR_ static const std::size_t _size_constant = \ BETTER_ENUMS_ID(BETTER_ENUMS_PP_COUNT(__VA_ARGS__)); \ BETTER_ENUMS_CONSTEXPR_ static std::size_t _size() \ { return _size_constant; } \ \ BETTER_ENUMS_CONSTEXPR_ static const char* _name(); \ BETTER_ENUMS_CONSTEXPR_ static _value_iterable _values(); \ ToStringConstexpr static _name_iterable _names(); \ \ _integral _value; \ \ BETTER_ENUMS_DEFAULT_CONSTRUCTOR(Enum) \ \ private: \ explicit BETTER_ENUMS_CONSTEXPR_ Enum(const _integral &value) : \ _value(value) { } \ \ DeclareInitialize \ \ BETTER_ENUMS_CONSTEXPR_ static _optional_index \ _from_value_loop(_integral value, std::size_t index = 0); \ BETTER_ENUMS_CONSTEXPR_ static _optional_index \ _from_string_loop(const char *name, std::size_t index = 0); \ BETTER_ENUMS_CONSTEXPR_ static _optional_index \ _from_string_nocase_loop(const char *name, std::size_t index = 0); \ \ friend struct ::better_enums::_initialize_at_program_start<Enum>; \}; \ \namespace better_enums_data_ ## Enum { \ \static ::better_enums::_initialize_at_program_start<Enum> \ _force_initialization; \ \enum _putNamesInThisScopeAlso { __VA_ARGS__ }; \ \BETTER_ENUMS_IGNORE_OLD_CAST_HEADER \BETTER_ENUMS_IGNORE_OLD_CAST_BEGIN \BETTER_ENUMS_CONSTEXPR_ const Enum _value_array[] = \ { BETTER_ENUMS_ID(BETTER_ENUMS_EAT_ASSIGN(Enum, __VA_ARGS__)) }; \BETTER_ENUMS_IGNORE_OLD_CAST_END \ \BETTER_ENUMS_ID(GenerateStrings(Enum, __VA_ARGS__)) \ \} \ \BETTER_ENUMS_IGNORE_ATTRIBUTES_HEADER \BETTER_ENUMS_IGNORE_ATTRIBUTES_BEGIN \BETTER_ENUMS_UNUSED BETTER_ENUMS_CONSTEXPR_ \inline const Enum \operator +(Enum::_enumerated enumerated) \{ \ return static_cast<Enum>(enumerated); \} \BETTER_ENUMS_IGNORE_ATTRIBUTES_END \ \BETTER_ENUMS_CONSTEXPR_ inline Enum::_optional_index \Enum::_from_value_loop(Enum::_integral value, std::size_t index) \{ \ return \ index == _size() ? \ _optional_index() : \ BETTER_ENUMS_NS(Enum)::_value_array[index]._value == value ? \ _optional_index(index) : \ _from_value_loop(value, index + 1); \} \ \BETTER_ENUMS_CONSTEXPR_ inline Enum::_optional_index \Enum::_from_string_loop(const char *name, std::size_t index) \{ \ return \ index == _size() ? _optional_index() : \ ::better_enums::_names_match( \ BETTER_ENUMS_NS(Enum)::_raw_names()[index], name) ? \ _optional_index(index) : \ _from_string_loop(name, index + 1); \} \ \BETTER_ENUMS_CONSTEXPR_ inline Enum::_optional_index \Enum::_from_string_nocase_loop(const char *name, std::size_t index) \{ \ return \ index == _size() ? _optional_index() : \ ::better_enums::_names_match_nocase( \ BETTER_ENUMS_NS(Enum)::_raw_names()[index], name) ? \ _optional_index(index) : \ _from_string_nocase_loop(name, index + 1); \} \ \BETTER_ENUMS_CONSTEXPR_ inline Enum::_integral Enum::_to_integral() const \{ \ return _integral(_value); \} \ \BETTER_ENUMS_CONSTEXPR_ inline std::size_t Enum::_to_index() const \{ \ return *_from_value_loop(_value); \} \ \BETTER_ENUMS_CONSTEXPR_ inline Enum \Enum::_from_index_unchecked(std::size_t index) \{ \ return \ ::better_enums::_or_zero(_from_index_nothrow(index)); \} \ \BETTER_ENUMS_CONSTEXPR_ inline Enum::_optional \Enum::_from_index_nothrow(std::size_t index) \{ \ return \ index >= _size() ? \ _optional() : \ _optional(BETTER_ENUMS_NS(Enum)::_value_array[index]); \} \ \BETTER_ENUMS_IF_EXCEPTIONS( \BETTER_ENUMS_CONSTEXPR_ inline Enum Enum::_from_index(std::size_t index) \{ \ return \ ::better_enums::_or_throw(_from_index_nothrow(index), \ #Enum "::_from_index: invalid argument"); \
} \) \ \BETTER_ENUMS_CONSTEXPR_ inline Enum \Enum::_from_integral_unchecked(_integral value) \{ \ return static_cast<_enumerated>(value); \} \ \BETTER_ENUMS_CONSTEXPR_ inline Enum::_optional \Enum::_from_integral_nothrow(_integral value) \{ \ return \ ::better_enums::_map_index<Enum>(BETTER_ENUMS_NS(Enum)::_value_array, \ _from_value_loop(value)); \} \ \BETTER_ENUMS_IF_EXCEPTIONS( \BETTER_ENUMS_CONSTEXPR_ inline Enum Enum::_from_integral(_integral value) \{ \ return \ ::better_enums::_or_throw(_from_integral_nothrow(value), \ #Enum "::_from_integral: invalid argument"); \
} \) \ \ToStringConstexpr inline const char* Enum::_to_string() const \{ \ return \ ::better_enums::_or_null( \ ::better_enums::_map_index<const char*>( \ BETTER_ENUMS_NS(Enum)::_name_array(), \ _from_value_loop(CallInitialize(_value)))); \} \ \BETTER_ENUMS_CONSTEXPR_ inline Enum::_optional \Enum::_from_string_nothrow(const char *name) \{ \ return \ ::better_enums::_map_index<Enum>( \ BETTER_ENUMS_NS(Enum)::_value_array, _from_string_loop(name)); \} \ \BETTER_ENUMS_IF_EXCEPTIONS( \BETTER_ENUMS_CONSTEXPR_ inline Enum Enum::_from_string(const char *name) \{ \ return \ ::better_enums::_or_throw(_from_string_nothrow(name), \ #Enum "::_from_string: invalid argument"); \
} \) \ \BETTER_ENUMS_CONSTEXPR_ inline Enum::_optional \Enum::_from_string_nocase_nothrow(const char *name) \{ \ return \ ::better_enums::_map_index<Enum>(BETTER_ENUMS_NS(Enum)::_value_array, \ _from_string_nocase_loop(name)); \} \ \BETTER_ENUMS_IF_EXCEPTIONS( \BETTER_ENUMS_CONSTEXPR_ inline Enum Enum::_from_string_nocase(const char *name)\{ \ return \ ::better_enums::_or_throw( \ _from_string_nocase_nothrow(name), \ #Enum "::_from_string_nocase: invalid argument"); \
} \) \ \BETTER_ENUMS_CONSTEXPR_ inline bool Enum::_is_valid(_integral value) \{ \ return _from_value_loop(value); \} \ \BETTER_ENUMS_CONSTEXPR_ inline bool Enum::_is_valid(const char *name) \{ \ return _from_string_loop(name); \} \ \BETTER_ENUMS_CONSTEXPR_ inline bool Enum::_is_valid_nocase(const char *name) \{ \ return _from_string_nocase_loop(name); \} \ \BETTER_ENUMS_CONSTEXPR_ inline const char* Enum::_name() \{ \ return #Enum; \} \ \BETTER_ENUMS_CONSTEXPR_ inline Enum::_value_iterable Enum::_values() \{ \ return _value_iterable(BETTER_ENUMS_NS(Enum)::_value_array, _size()); \} \ \ToStringConstexpr inline Enum::_name_iterable Enum::_names() \{ \ return \ _name_iterable(BETTER_ENUMS_NS(Enum)::_name_array(), \ CallInitialize(_size())); \} \ \DefineInitialize(Enum) \ \BETTER_ENUMS_IGNORE_ATTRIBUTES_HEADER \BETTER_ENUMS_IGNORE_ATTRIBUTES_BEGIN \BETTER_ENUMS_UNUSED BETTER_ENUMS_CONSTEXPR_ \inline bool operator ==(const Enum &a, const Enum &b) \ { return a._to_integral() == b._to_integral(); } \ \BETTER_ENUMS_UNUSED BETTER_ENUMS_CONSTEXPR_ \inline bool operator !=(const Enum &a, const Enum &b) \ { return a._to_integral() != b._to_integral(); } \ \BETTER_ENUMS_UNUSED BETTER_ENUMS_CONSTEXPR_ \inline bool operator <(const Enum &a, const Enum &b) \ { return a._to_integral() < b._to_integral(); } \ \BETTER_ENUMS_UNUSED BETTER_ENUMS_CONSTEXPR_ \inline bool operator <=(const Enum &a, const Enum &b) \ { return a._to_integral() <= b._to_integral(); } \ \BETTER_ENUMS_UNUSED BETTER_ENUMS_CONSTEXPR_ \inline bool operator >(const Enum &a, const Enum &b) \ { return a._to_integral() > b._to_integral(); } \ \BETTER_ENUMS_UNUSED BETTER_ENUMS_CONSTEXPR_ \inline bool operator >=(const Enum &a, const Enum &b) \ { return a._to_integral() >= b._to_integral(); } \BETTER_ENUMS_IGNORE_ATTRIBUTES_END \ \ \template <typename Char, typename Traits> \std::basic_ostream<Char, Traits>& \operator <<(std::basic_ostream<Char, Traits>& stream, const Enum &value) \{ \ return stream << value._to_string(); \} \ \template <typename Char, typename Traits> \std::basic_istream<Char, Traits>& \operator >>(std::basic_istream<Char, Traits>& stream, Enum &value) \{ \ std::basic_string<Char, Traits> buffer; \ \ stream >> buffer; \ ::better_enums::optional<Enum> converted = \ Enum::_from_string_nothrow(buffer.c_str()); \ \ if (converted) \ value = *converted; \ else \ stream.setstate(std::basic_istream<Char, Traits>::failbit); \ \ return stream; \}
// Enum feature options.
// C++98, C++11
#define BETTER_ENUMS_CXX98_UNDERLYING_TYPE(Underlying)
// C++11
#define BETTER_ENUMS_CXX11_UNDERLYING_TYPE(Underlying) \
: Underlying
#if defined(_MSC_VER) && _MSC_VER >= 1700
// VS 2012 and above fully support strongly typed enums and will warn about
// incorrect usage.
# define BETTER_ENUMS_LEGACY_UNDERLYING_TYPE(Underlying) \
BETTER_ENUMS_CXX11_UNDERLYING_TYPE(Underlying)#else
# define BETTER_ENUMS_LEGACY_UNDERLYING_TYPE(Underlying) \
BETTER_ENUMS_CXX98_UNDERLYING_TYPE(Underlying)#endif
// C++98, C++11
#define BETTER_ENUMS_REGULAR_ENUM_SWITCH_TYPE(Type) \
_enumerated
// C++11
#define BETTER_ENUMS_ENUM_CLASS_SWITCH_TYPE(Type) \
BETTER_ENUMS_NS(Type)::_enumClassForSwitchStatements
// C++98, C++11
#define BETTER_ENUMS_REGULAR_ENUM_SWITCH_TYPE_GENERATE(Underlying, ...)
// C++11
#define BETTER_ENUMS_ENUM_CLASS_SWITCH_TYPE_GENERATE(Underlying, ...) \
enum class _enumClassForSwitchStatements : Underlying { __VA_ARGS__ };
// C++98
#define BETTER_ENUMS_CXX98_TRIM_STRINGS_ARRAYS(Enum, ...) \
inline const char** _raw_names() \ { \ static const char *value[] = \ { BETTER_ENUMS_ID(BETTER_ENUMS_STRINGIZE(__VA_ARGS__)) }; \ return value; \ } \ \ inline char* _name_storage() \ { \ static char storage[] = \ BETTER_ENUMS_ID(BETTER_ENUMS_RESERVE_STORAGE(__VA_ARGS__)); \ return storage; \ } \ \ inline const char** _name_array() \ { \ static const char *value[Enum::_size_constant]; \ return value; \ } \ \ inline bool& _initialized() \ { \ static bool value = false; \ return value; \ }
// C++11 fast version
#define BETTER_ENUMS_CXX11_PARTIAL_CONSTEXPR_TRIM_STRINGS_ARRAYS(Enum, ...) \
constexpr const char *_the_raw_names[] = \ { BETTER_ENUMS_ID(BETTER_ENUMS_STRINGIZE(__VA_ARGS__)) }; \ \ constexpr const char * const * _raw_names() \ { \ return _the_raw_names; \ } \ \ inline char* _name_storage() \ { \ static char storage[] = \ BETTER_ENUMS_ID(BETTER_ENUMS_RESERVE_STORAGE(__VA_ARGS__)); \ return storage; \ } \ \ inline const char** _name_array() \ { \ static const char *value[Enum::_size_constant]; \ return value; \ } \ \ inline bool& _initialized() \ { \ static bool value = false; \ return value; \ }
// C++11 slow all-constexpr version
#define BETTER_ENUMS_CXX11_FULL_CONSTEXPR_TRIM_STRINGS_ARRAYS(Enum, ...) \
BETTER_ENUMS_ID(BETTER_ENUMS_TRIM_STRINGS(__VA_ARGS__)) \ \ constexpr const char * const _the_name_array[] = \ { BETTER_ENUMS_ID(BETTER_ENUMS_REFER_TO_STRINGS(__VA_ARGS__)) }; \ \ constexpr const char * const * _name_array() \ { \ return _the_name_array; \ } \ \ constexpr const char * const * _raw_names() \ { \ return _the_name_array; \ }
// C++98, C++11 fast version
#define BETTER_ENUMS_NO_CONSTEXPR_TO_STRING_KEYWORD
// C++11 slow all-constexpr version
#define BETTER_ENUMS_CONSTEXPR_TO_STRING_KEYWORD \
constexpr
// C++98, C++11 fast version
#define BETTER_ENUMS_DO_DECLARE_INITIALIZE \
static int initialize();
// C++11 slow all-constexpr version
#define BETTER_ENUMS_DECLARE_EMPTY_INITIALIZE \
static int initialize() { return 0; }
// C++98, C++11 fast version
#define BETTER_ENUMS_DO_DEFINE_INITIALIZE(Enum) \
inline int Enum::initialize() \ { \ if (BETTER_ENUMS_NS(Enum)::_initialized()) \ return 0; \ \ ::better_enums::_trim_names(BETTER_ENUMS_NS(Enum)::_raw_names(), \ BETTER_ENUMS_NS(Enum)::_name_array(), \ BETTER_ENUMS_NS(Enum)::_name_storage(), \ _size()); \ \ BETTER_ENUMS_NS(Enum)::_initialized() = true; \ \ return 0; \ }
// C++11 slow all-constexpr version
#define BETTER_ENUMS_DO_NOT_DEFINE_INITIALIZE(Enum)
// C++98, C++11 fast version
#define BETTER_ENUMS_DO_CALL_INITIALIZE(value) \
::better_enums::continue_with(initialize(), value)
// C++11 slow all-constexpr version
#define BETTER_ENUMS_DO_NOT_CALL_INITIALIZE(value) \
value
// User feature selection.
#ifdef BETTER_ENUMS_STRICT_CONVERSION
# define BETTER_ENUMS_DEFAULT_SWITCH_TYPE \
BETTER_ENUMS_ENUM_CLASS_SWITCH_TYPE# define BETTER_ENUMS_DEFAULT_SWITCH_TYPE_GENERATE \
BETTER_ENUMS_ENUM_CLASS_SWITCH_TYPE_GENERATE#else
# define BETTER_ENUMS_DEFAULT_SWITCH_TYPE \
BETTER_ENUMS_REGULAR_ENUM_SWITCH_TYPE# define BETTER_ENUMS_DEFAULT_SWITCH_TYPE_GENERATE \
BETTER_ENUMS_REGULAR_ENUM_SWITCH_TYPE_GENERATE#endif
#ifndef BETTER_ENUMS_DEFAULT_CONSTRUCTOR
# define BETTER_ENUMS_DEFAULT_CONSTRUCTOR(Enum) \
private: \ Enum() : _value(0) { }#endif
#ifdef BETTER_ENUMS_HAVE_CONSTEXPR
#ifdef BETTER_ENUMS_CONSTEXPR_TO_STRING
# define BETTER_ENUMS_DEFAULT_TRIM_STRINGS_ARRAYS \
BETTER_ENUMS_CXX11_FULL_CONSTEXPR_TRIM_STRINGS_ARRAYS# define BETTER_ENUMS_DEFAULT_TO_STRING_KEYWORD \
BETTER_ENUMS_CONSTEXPR_TO_STRING_KEYWORD# define BETTER_ENUMS_DEFAULT_DECLARE_INITIALIZE \
BETTER_ENUMS_DECLARE_EMPTY_INITIALIZE# define BETTER_ENUMS_DEFAULT_DEFINE_INITIALIZE \
BETTER_ENUMS_DO_NOT_DEFINE_INITIALIZE# define BETTER_ENUMS_DEFAULT_CALL_INITIALIZE \
BETTER_ENUMS_DO_NOT_CALL_INITIALIZE#else
# define BETTER_ENUMS_DEFAULT_TRIM_STRINGS_ARRAYS \
BETTER_ENUMS_CXX11_PARTIAL_CONSTEXPR_TRIM_STRINGS_ARRAYS# define BETTER_ENUMS_DEFAULT_TO_STRING_KEYWORD \
BETTER_ENUMS_NO_CONSTEXPR_TO_STRING_KEYWORD# define BETTER_ENUMS_DEFAULT_DECLARE_INITIALIZE \
BETTER_ENUMS_DO_DECLARE_INITIALIZE# define BETTER_ENUMS_DEFAULT_DEFINE_INITIALIZE \
BETTER_ENUMS_DO_DEFINE_INITIALIZE# define BETTER_ENUMS_DEFAULT_CALL_INITIALIZE \
BETTER_ENUMS_DO_CALL_INITIALIZE#endif
// Top-level macros.
#define BETTER_ENUM(Enum, Underlying, ...) \
BETTER_ENUMS_ID(BETTER_ENUMS_TYPE( \ BETTER_ENUMS_CXX11_UNDERLYING_TYPE, \ BETTER_ENUMS_DEFAULT_SWITCH_TYPE, \ BETTER_ENUMS_DEFAULT_SWITCH_TYPE_GENERATE, \ BETTER_ENUMS_DEFAULT_TRIM_STRINGS_ARRAYS, \ BETTER_ENUMS_DEFAULT_TO_STRING_KEYWORD, \ BETTER_ENUMS_DEFAULT_DECLARE_INITIALIZE, \ BETTER_ENUMS_DEFAULT_DEFINE_INITIALIZE, \ BETTER_ENUMS_DEFAULT_CALL_INITIALIZE, \ Enum, Underlying, __VA_ARGS__))
#define SLOW_ENUM(Enum, Underlying, ...) \
BETTER_ENUMS_ID(BETTER_ENUMS_TYPE( \ BETTER_ENUMS_CXX11_UNDERLYING_TYPE, \ BETTER_ENUMS_DEFAULT_SWITCH_TYPE, \ BETTER_ENUMS_DEFAULT_SWITCH_TYPE_GENERATE, \ BETTER_ENUMS_CXX11_FULL_CONSTEXPR_TRIM_STRINGS_ARRAYS, \ BETTER_ENUMS_CONSTEXPR_TO_STRING_KEYWORD, \ BETTER_ENUMS_DECLARE_EMPTY_INITIALIZE, \ BETTER_ENUMS_DO_NOT_DEFINE_INITIALIZE, \ BETTER_ENUMS_DO_NOT_CALL_INITIALIZE, \ Enum, Underlying, __VA_ARGS__))
#else
#define BETTER_ENUM(Enum, Underlying, ...) \
BETTER_ENUMS_ID(BETTER_ENUMS_TYPE( \ BETTER_ENUMS_LEGACY_UNDERLYING_TYPE, \ BETTER_ENUMS_DEFAULT_SWITCH_TYPE, \ BETTER_ENUMS_DEFAULT_SWITCH_TYPE_GENERATE, \ BETTER_ENUMS_CXX98_TRIM_STRINGS_ARRAYS, \ BETTER_ENUMS_NO_CONSTEXPR_TO_STRING_KEYWORD, \ BETTER_ENUMS_DO_DECLARE_INITIALIZE, \ BETTER_ENUMS_DO_DEFINE_INITIALIZE, \ BETTER_ENUMS_DO_CALL_INITIALIZE, \ Enum, Underlying, __VA_ARGS__))
#endif
namespace better_enums {
// Maps.
template <typename T>struct map_compare { BETTER_ENUMS_CONSTEXPR_ static bool less(const T& a, const T& b) { return a < b; }};
template <>struct map_compare<const char*> { BETTER_ENUMS_CONSTEXPR_ static bool less(const char *a, const char *b) { return less_loop(a, b); }
private: BETTER_ENUMS_CONSTEXPR_ static bool less_loop(const char *a, const char *b, size_t index = 0) { return a[index] != b[index] ? a[index] < b[index] : a[index] == '\0' ? false : less_loop(a, b, index + 1); }};
template <>struct map_compare<const wchar_t*> { BETTER_ENUMS_CONSTEXPR_ static bool less(const wchar_t *a, const wchar_t *b) { return less_loop(a, b); }
private: BETTER_ENUMS_CONSTEXPR_ static bool less_loop(const wchar_t *a, const wchar_t *b, size_t index = 0) { return a[index] != b[index] ? a[index] < b[index] : a[index] == L'\0' ? false : less_loop(a, b, index + 1); }};
template <typename Enum, typename T, typename Compare = map_compare<T> >struct map { typedef T (*function)(Enum);
BETTER_ENUMS_CONSTEXPR_ explicit map(function f) : _f(f) { }
BETTER_ENUMS_CONSTEXPR_ T from_enum(Enum value) const { return _f(value); } BETTER_ENUMS_CONSTEXPR_ T operator [](Enum value) const { return _f(value); }
BETTER_ENUMS_CONSTEXPR_ Enum to_enum(T value) const { return _or_throw(to_enum_nothrow(value), "map::to_enum: invalid argument"); }
BETTER_ENUMS_CONSTEXPR_ optional<Enum> to_enum_nothrow(T value, size_t index = 0) const { return index >= Enum::_size() ? optional<Enum>() : Compare::less(_f(Enum::_values()[index]), value) || Compare::less(value, _f(Enum::_values()[index])) ? to_enum_nothrow(value, index + 1) : Enum::_values()[index]; }
private: const function _f;};
template <typename Enum, typename T>BETTER_ENUMS_CONSTEXPR_ map<Enum, T> make_map(T (*f)(Enum)){ return map<Enum, T>(f);}
}
#define BETTER_ENUMS_DECLARE_STD_HASH(type) \
namespace std { \ template <> struct hash<type> \ { \ size_t operator()(const type &x) const \ { \ return std::hash<size_t>()(x._to_integral()); \ } \ }; \ }
#endif // #ifndef BETTER_ENUMS_ENUM_H
|
