Cereal: Gemeinsame Serialisierungsfunktion über Aufzählungen

Question

Lets Angenommen, ich habe so etwas wie:

enum t_color { BLUE=0,RED,GREEN}; 
vector<string> TAG_color={"BLUE", "RED", "GREEN"}; 

enum t_colores { AZUL=0,ROJO,VERDE}; 
vector<string> TAG_colores={"AZUL", "ROJO", "VERDE"}; 

I (in Getreide) verwendet werden soll, eine gemeinsame save_minimal, wie zum Beispiel:

template <class Archive,typename T > inline 
    std::string save_minimal(Archive const &, typename std::enable_if< std::is_enum<T>::value, T >::type const & t) 
    { 
    std::string ret="Unknown"; 
    if (std::is_same<T,t_color>::value) 
    { 
     ret=TAG_color[t]; 
    } 
    else if ( std::is_same<T,t_colores>::value) 
    { 
     ret=TAG_colores[t]; 
    } 
    return ret; 
} 

Es kompiliert aber scheint wie Müsli ignoriert die Vorlage. Es verwendet nur den Wert "integer" der Enumeration.

Answer 1

Yep ... es ist machbar (aber nicht direkt durch Getreide):

#define SERIALIZE_ENUM(enumname)            \ 
template <class Archive> inline            \ 
std::string save_minimal(Archive const &, t_##enumname const & t)   \ 
{                    \ 
    return std::string(TAG_##enumname[t]);          \ 
}                    \ 
template <class Archive> inline            \ 
void load_minimal(Archive const&, t_##enumname & t,std::string const& value) \ 
{                    \ 
    int a=0;                  \ 
    for (auto const &tag:TAG_##enumname)           \ 
    {                   \ 
    if (tag == value)              \ 
    {                   \ 
     t = static_cast<t_##enumname>(a);          \ 
     return;                 \ 
    }                   \ 
    a++;                  \ 
    }                   \ 

namespace cereal { 
    SERIALIZE_ENUM(color) 
    SERIALIZE_ENUM(colores) 
}