fork download

copy

#include <iostream>
#include <string>
#include <vector>
#include <map>
 
 
// http://stackoverflow.com/questions/236129/how-to-split-a-string-in-c
std::vector<std::string> split(const std::string &text, char sep) {
    std::vector<std::string> tokens;
    size_t start = 0, end = 0;
    while ((end = text.find(sep, start)) != std::string::npos) {
        tokens.push_back(text.substr(start, end - start));
        start = end + 1;
    }
    tokens.push_back(text.substr(start));
    return tokens;
}
 
std::vector<std::string> parse(const char* args)
{
    return split(args, ',');
}
 
std::vector<std::string> parse(const char* args);
 
template<typename T, typename ...Ts>
std::map<T, std::string> make_map(const char* text, Ts... args)
{
    std::vector<T> keys{args...};
    std::vector<std::string> vals = parse(text);
    auto k = keys.cbegin();
    auto v = vals.cbegin();
    std::map<T, std::string> r;
    for (; k != keys.cend(); k++, v++) {
        r.emplace(*k, *v);
    }
    return r;
 
}
 
#define ENUM(name, ...)                                                              \
enum name                                                                            \
{                                                                                    \
    __VA_ARGS__                                                                      \
};                                                                                   \
static std::string to_string(const name v) {                                         \
    static std::map<name, std::string> m {make_map<name>(#__VA_ARGS__, __VA_ARGS__)};\
    return m.at(v);                                                                  \
}
 
 
ENUM(Color, Red,Green,Blue)
namespace ns {
ENUM(Alignment, Left,Right)
}
 
class X
{
public:
    ENUM(Y,A=8,B,C)
};
 
 
int main(int , char**)
{
    std::cout << to_string(Red) << to_string(Blue);
    std::cout << to_string(ns::Left) << to_string(ns::Right);
    std::cout << X::to_string(X::A) << X::to_string(X::B);
    return 0;
}
 

prog.cpp: In static member function 'static std::string X::to_string(X::Y)':
prog.cpp:60:13: error: lvalue required as left operand of assignment
     ENUM(Y,A=8,B,C)
             ^
prog.cpp:47:72: note: in definition of macro 'ENUM'
     static std::map<name, std::string> m {make_map<name>(#__VA_ARGS__, __VA_ARGS__)};\
                                                                        ^
prog.cpp:47:84: error: no matching function for call to 'std::map<X::Y, std::basic_string<char> >::map(<brace-enclosed initializer list>)'
     static std::map<name, std::string> m {make_map<name>(#__VA_ARGS__, __VA_ARGS__)};\
                                                                                    ^
prog.cpp:60:5: note: in expansion of macro 'ENUM'
     ENUM(Y,A=8,B,C)
     ^
In file included from /usr/include/c++/5/map:61:0,
                 from prog.cpp:4:
/usr/include/c++/5/bits/stl_map.h:273:9: note: candidate: template<class _InputIterator> std::map<_Key, _Tp, _Compare, _Alloc>::map(_InputIterator, _InputIterator, const _Compare&, const allocator_type&)
         map(_InputIterator __first, _InputIterator __last,
         ^
/usr/include/c++/5/bits/stl_map.h:273:9: note:   template argument deduction/substitution failed:
/usr/include/c++/5/bits/stl_map.h:256:9: note: candidate: template<class _InputIterator> std::map<_Key, _Tp, _Compare, _Alloc>::map(_InputIterator, _InputIterator)
         map(_InputIterator __first, _InputIterator __last)
         ^
/usr/include/c++/5/bits/stl_map.h:256:9: note:   template argument deduction/substitution failed:
/usr/include/c++/5/bits/stl_map.h:239:9: note: candidate: template<class _InputIterator> std::map<_Key, _Tp, _Compare, _Alloc>::map(_InputIterator, _InputIterator, const allocator_type&)
         map(_InputIterator __first, _InputIterator __last,
         ^
/usr/include/c++/5/bits/stl_map.h:239:9: note:   template argument deduction/substitution failed:
/usr/include/c++/5/bits/stl_map.h:233:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::map(std::initializer_list<std::pair<const _Key, _Tp> >, const allocator_type&) [with _Key = X::Y; _Tp = std::basic_string<char>; _Compare = std::less<X::Y>; _Alloc = std::allocator<std::pair<const X::Y, std::basic_string<char> > >; std::map<_Key, _Tp, _Compare, _Alloc>::allocator_type = std::allocator<std::pair<const X::Y, std::basic_string<char> > >]
       map(initializer_list<value_type> __l, const allocator_type& __a)
       ^
/usr/include/c++/5/bits/stl_map.h:233:7: note:   candidate expects 2 arguments, 1 provided
/usr/include/c++/5/bits/stl_map.h:227:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::map(std::map<_Key, _Tp, _Compare, _Alloc>&&, const allocator_type&) [with _Key = X::Y; _Tp = std::basic_string<char>; _Compare = std::less<X::Y>; _Alloc = std::allocator<std::pair<const X::Y, std::basic_string<char> > >; std::map<_Key, _Tp, _Compare, _Alloc>::allocator_type = std::allocator<std::pair<const X::Y, std::basic_string<char> > >]
       map(map&& __m, const allocator_type& __a)
       ^
/usr/include/c++/5/bits/stl_map.h:227:7: note:   candidate expects 2 arguments, 1 provided
/usr/include/c++/5/bits/stl_map.h:223:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::map(const std::map<_Key, _Tp, _Compare, _Alloc>&, const allocator_type&) [with _Key = X::Y; _Tp = std::basic_string<char>; _Compare = std::less<X::Y>; _Alloc = std::allocator<std::pair<const X::Y, std::basic_string<char> > >; std::map<_Key, _Tp, _Compare, _Alloc>::allocator_type = std::allocator<std::pair<const X::Y, std::basic_string<char> > >]
       map(const map& __m, const allocator_type& __a)
       ^
/usr/include/c++/5/bits/stl_map.h:223:7: note:   candidate expects 2 arguments, 1 provided
/usr/include/c++/5/bits/stl_map.h:219:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::map(const allocator_type&) [with _Key = X::Y; _Tp = std::basic_string<char>; _Compare = std::less<X::Y>; _Alloc = std::allocator<std::pair<const X::Y, std::basic_string<char> > >; std::map<_Key, _Tp, _Compare, _Alloc>::allocator_type = std::allocator<std::pair<const X::Y, std::basic_string<char> > >]
       map(const allocator_type& __a)
       ^
/usr/include/c++/5/bits/stl_map.h:219:7: note:   conversion of argument 1 would be ill-formed:
/usr/include/c++/5/bits/stl_map.h:211:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::map(std::initializer_list<std::pair<const _Key, _Tp> >, const _Compare&, const allocator_type&) [with _Key = X::Y; _Tp = std::basic_string<char>; _Compare = std::less<X::Y>; _Alloc = std::allocator<std::pair<const X::Y, std::basic_string<char> > >; std::map<_Key, _Tp, _Compare, _Alloc>::allocator_type = std::allocator<std::pair<const X::Y, std::basic_string<char> > >]
       map(initializer_list<value_type> __l,
       ^
/usr/include/c++/5/bits/stl_map.h:211:7: note:   conversion of argument 1 would be ill-formed:
/usr/include/c++/5/bits/stl_map.h:196:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::map(std::map<_Key, _Tp, _Compare, _Alloc>&&) [with _Key = X::Y; _Tp = std::basic_string<char>; _Compare = std::less<X::Y>; _Alloc = std::allocator<std::pair<const X::Y, std::basic_string<char> > >]
       map(map&& __x)
       ^
/usr/include/c++/5/bits/stl_map.h:196:7: note:   conversion of argument 1 would be ill-formed:
/usr/include/c++/5/bits/stl_map.h:185:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::map(const std::map<_Key, _Tp, _Compare, _Alloc>&) [with _Key = X::Y; _Tp = std::basic_string<char>; _Compare = std::less<X::Y>; _Alloc = std::allocator<std::pair<const X::Y, std::basic_string<char> > >]
       map(const map& __x)
       ^
/usr/include/c++/5/bits/stl_map.h:185:7: note:   conversion of argument 1 would be ill-formed:
/usr/include/c++/5/bits/stl_map.h:174:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::map(const _Compare&, const allocator_type&) [with _Key = X::Y; _Tp = std::basic_string<char>; _Compare = std::less<X::Y>; _Alloc = std::allocator<std::pair<const X::Y, std::basic_string<char> > >; std::map<_Key, _Tp, _Compare, _Alloc>::allocator_type = std::allocator<std::pair<const X::Y, std::basic_string<char> > >]
       map(const _Compare& __comp,
       ^
/usr/include/c++/5/bits/stl_map.h:174:7: note:   conversion of argument 1 would be ill-formed:
/usr/include/c++/5/bits/stl_map.h:162:7: note: candidate: std::map<_Key, _Tp, _Compare, _Alloc>::map() [with _Key = X::Y; _Tp = std::basic_string<char>; _Compare = std::less<X::Y>; _Alloc = std::allocator<std::pair<const X::Y, std::basic_string<char> > >]
       map()
       ^
/usr/include/c++/5/bits/stl_map.h:162:7: note:   candidate expects 0 arguments, 1 provided

Standard output is empty