#include #include #include namespace tmp { template struct identity { typedef T type; }; template struct constant { static constexpr T value = V; }; template struct bool_ : constant {}; template struct tpair {}; template struct first; template struct first> : identity {}; template struct second; template struct second> : identity {}; template struct tstring {}; template struct c_str; template struct c_str> { static char const value[]; }; template char const c_str>::value[] = { S..., 0 }; template struct tlist : identity> {}; template struct empty : bool_ {}; template <> struct empty> : bool_ {}; template struct push_front; template struct push_front> : tlist {}; template struct pop_front; template struct pop_front> : tlist {}; template struct front; template struct front> : identity {}; template < typename T, typename List, template class Less > struct insert_sorted; template < typename T, template class Less > struct insert_sorted, Less> : tlist {}; template < typename T, typename Head, typename... Tail, template class Less > struct insert_sorted, Less> : std::conditional < Less::value, tlist, typename push_front, Less>::type>::type >::type {}; template < template class Less, typename List > struct sort; template < template class Less > struct sort> : tlist<> {}; template < template class Less, typename Head, typename... Tail > struct sort> : insert_sorted>::type, Less> {}; template struct string_less; template <> struct string_less, tstring<>> : bool_ {}; template struct string_less, tstring<>> : bool_ {}; template struct string_less, tstring> : bool_ {}; template struct string_less, tstring> : bool_ < Head1 == Head2 ? string_less, tstring>::value : (Head1 < Head2) > {}; template struct pair_less; template struct pair_less, tpair> : string_less {}; template struct take_n; template <> struct take_n<0, tlist<>> { typedef tlist<> left; typedef tlist<> right; }; template struct take_n<0, tlist> { typedef tlist<> left; typedef tlist right; }; template class take_n> { typedef take_n> recurse; public: typedef typename push_front::type left; typedef typename recurse::right right; }; template struct cut_half_with_median; template class cut_half_with_median> { typedef take_n> left_without_median; typedef take_n<1, typename left_without_median::right> median_with_right; public: typedef typename left_without_median::left left; typedef typename front::type median; typedef typename median_with_right::right right; }; template class decision_tree { typedef cut_half_with_median cut; typedef typename cut::median median; Enum not_found(std::string const& value) const { throw std::invalid_argument{ "string '" + value + "' has no enum value" }; } Enum less(char const* value, bool_) const { return not_found(value); } Enum less(char const* value, bool_) const { return decision_tree()(value); } Enum greater(char const* value, bool_) const { return not_found(value); } Enum greater(char const* value, bool_) const { return decision_tree()(value); } public: Enum operator () (char const* value) const { auto cmp = std::strcmp(value, c_str::type>::value); if(cmp < 0) return less(value, bool_::value>()); if(cmp > 0) return greater(value, bool_::value>()); return first::type::value; } }; template struct enum_mapper; template class enum_mapper, Strings>...> { typedef tlist, Strings>...> mappings; typedef typename sort::type sorted_mappings; public: Enum operator () (char const* value) const { return decision_tree()(value); } }; } #define EMAP(E, ...) tmp::tpair, tmp::tstring<__VA_ARGS__>> //////////////////////////////////////////////////////////////// #include enum struct my_enum : unsigned { foo, bar, baz, qux, }; std::ostream& operator << (std::ostream& os, my_enum e) { static char const* const table[] = { "foo", "bar", "baz", "qux" }; return os << table[static_cast(e)]; } int main() { typedef tmp::enum_mapper < my_enum, EMAP(my_enum::baz, 'b','a','z'), EMAP(my_enum::bar, 'b','a','r'), EMAP(my_enum::foo, 'f','o','o'), EMAP(my_enum::qux, 'q','u','x') > my_enum_mapper; my_enum_mapper mapper; std::cout << mapper("foo") << '\n'; std::cout << mapper("bar") << '\n'; std::cout << mapper("baz") << '\n'; std::cout << mapper("qux") << '\n'; try { std::cout << mapper("garbage") << '\n'; } catch(std::invalid_argument const& iv) { std::cout << iv.what() << '\n'; } }