Enum.h

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <iostream>
#include <map>
#include <vector>
#include "String/Exceptions.h"
 
class gorgon__no_enum_trait {
public:
    static const bool isupgradedenum=false;
};
 
template<class T_>
gorgon__no_enum_trait gorgon__enum_tr_loc(T_);
 
namespace Gorgon {
 
 
    template<class T_>
    class expandedenumtraits {
    public:
        static_assert(decltype(gorgon__enum_tr_loc(T_()))::isupgradedenum, "Should be an enum");
        
        expandedenumtraits() {
            T_ prev=traits.mapping.begin()->first;
            listing.push_back(prev);
            for(auto p : traits.mapping) {
                for(auto &c : p.second) c=tolower(c);
                
                reversemapping.insert(std::make_pair(p.second, p.first));
                if(p.first!=prev) {
                    listing.push_back(p.first);
                    prev=p.first;
                }
            }
        }
        
        bool lookupstring(T_ e, std::string &s) const {
            auto item=traits.mapping.find(e);
            if(item==traits.mapping.end()) return false;
            s=item->second;
            return true;
        }
        
        bool lookupvalue(std::string s, T_ &e) const {
            for(auto &c : s) c=tolower(c);
            
            auto item=reversemapping.find(s);
            if(item==reversemapping.end()) return false;
            e=item->second;
            return true;
        }
        
        typename std::vector<T_>::const_iterator 
        begin() const {
            return listing.begin();
        }
        
        typename std::vector<T_>::const_iterator 
        end() const {
            return listing.end();
        }
        
    private:
        const decltype(gorgon__enum_tr_loc(T_())) traits;
        std::map<std::string, T_> reversemapping;
        std::vector<T_> listing;
    };
 
    template<class T_>
    class staticenumtraits {
    public:
        static_assert(decltype(gorgon__enum_tr_loc(T_()))::isupgradedenum, "Should be an enum");
        
        static bool lookupstring(T_ e, std::string &s) {
            return traits.lookupstring(e, s);
        }
        
        static bool lookupvalue(const std::string &s, T_ &e) {
            return traits.lookupvalue(s, e);
        }
        
        static typename std::vector<T_>::const_iterator begin() {
            return traits.begin();
        }
        
        static typename std::vector<T_>::const_iterator end() {
            return traits.end();
        }
        
        static const expandedenumtraits<T_> traits;
    };
 
    template<class T_> 
    const expandedenumtraits<T_> staticenumtraits<T_>::traits;
    
    template<class T_>
    class enum_type_id {};
    
 
    #define DefineEnumStrings(type, ...) \
    class gorgon_enumtraits_##type {\
    public:\
        gorgon_enumtraits_##type() : mapping({__VA_ARGS__}) { }\
        \
        static const bool isupgradedenum=true;\
        \
        static const char *name() { return #type; }\
        \
        const std::multimap<type, std::string> mapping;\
    };\
    gorgon_enumtraits_##type gorgon__enum_tr_loc(type);
 
    #define DefineEnumStringsTN(type, typname, ...) \
    class gorgon_enumtraits_##type {\
    public:\
        gorgon_enumtraits_##type() : mapping({__VA_ARGS__}) { }\
        \
        static const bool isupgradedenum=true;\
        \
        static const char *name() { return typname; }\
        \
        const std::multimap<type, std::string> mapping;\
    };\
    gorgon_enumtraits_##type gorgon__enum_tr_loc(type);
 
    #define DefineEnumStringsCM(clsname, type, ...) \
    class gorgon_enumtraits_##type {\
    public:\
        gorgon_enumtraits_##type() : mapping({__VA_ARGS__}) { }\
        \
        static const bool isupgradedenum=true;\
        \
        static const char *name() { return #type; }\
        \
        const std::multimap<clsname::type, std::string> mapping;\
    };\
    gorgon_enumtraits_##type gorgon__enum_tr_loc(clsname::type);
 
    #define DefineEnumStringsCMTN(clsname, type, typname, ...) \
    class gorgon_enumtraits_##type {\
    public:\
        gorgon_enumtraits_##type() : mapping({__VA_ARGS__}) { }\
        \
        static const bool isupgradedenum=true;\
        \
        static const char *name() { return typname; }\
        \
        const std::multimap<clsname::type, std::string> mapping;\
    };\
    gorgon_enumtraits_##type gorgon__enum_tr_loc(clsname::type);
    
    template<class T_>
    typename std::enable_if<decltype(gorgon__enum_tr_loc(T_()))::isupgradedenum, enum_type_id<T_>>::type 
    Enumerate() {
        return enum_type_id<T_>();
    }
 
    template <class T_>
    typename std::vector<T_>::const_iterator 
    begin(enum_type_id<T_>) {
        return staticenumtraits<T_>::begin();
    }
 
    template <class T_>
    typename std::vector<T_>::const_iterator end(enum_type_id<T_>) {
        return staticenumtraits<T_>::end();
    }
 
    namespace String {
        template<class T_>
        typename std::enable_if<decltype(gorgon__enum_tr_loc(T_()))::isupgradedenum, T_>::type 
        To(const std::string &text) {
            T_ e;
            if(!staticenumtraits<T_>::lookupvalue(text, e)) return T_();
            return e;
        }
        
        template<class T_>
        typename std::enable_if<decltype(gorgon__enum_tr_loc(T_()))::isupgradedenum, std::string>::type 
        From(const T_ &e) {
            std::string s;
            if(!staticenumtraits<T_>::lookupstring(e, s)) return "";
            return s;
        }
        
        template<class T_>
        typename std::enable_if<decltype(gorgon__enum_tr_loc(T_()))::isupgradedenum, T_>::type 
        Parse(const std::string &text) {
            T_ e;
            if(!staticenumtraits<T_>::lookupvalue(text, e)) {
                std::string s ="\""+text+"\" is not a valid ";
                s+=decltype(gorgon__enum_tr_loc(T_()))::name();
                throw ParseError(20001, s);
            }
            return e;
        }
    }
}
 
template<class T_>
typename std::enable_if<decltype(gorgon__enum_tr_loc(T_()))::isupgradedenum, std::ostream&>::type 
operator <<(std::ostream &out, const T_ &e) {
    std::string s;
    if(!Gorgon::staticenumtraits<T_>::lookupstring(e, s)) return out;
    out<<s;
    
    return out;
}
 
template<class T_>
typename std::enable_if<decltype(gorgon__enum_tr_loc(T_()))::isupgradedenum, std::istream&>::type 
operator >>(std::istream &in, T_ &e) {
    std::string s;
    e=T_();
    in>>s;
    if(!Gorgon::staticenumtraits<T_>::lookupvalue(s, e)) in.setstate(in.badbit);
    
    return in;
}
 
namespace std {
    template<class T_>
    typename std::enable_if<decltype(gorgon__enum_tr_loc(T_()))::isupgradedenum, std::istream&>::type 
    getline(std::istream &in, T_ &e) {
        std::string s;
        e=T_();
        std::getline(in, s);
        unsigned i=0;
        while(s.length()>i && isspace(s[i])) i++;
        s=s.substr(i);
 
        if(!Gorgon::staticenumtraits<T_>::lookupvalue(s, e)) in.setstate(in.badbit);
        
        return in;
    }
}