Synchronized enumerations

The problem.

The problem with synchronizing things is that it generally cannot be done automatically, the user is usually in charge of specifying how each entity is related; this point of customization is usually unavoidable and making it as comfortable as possible and not error-prone is the tricky part.

Proposal.

When faced with a similar problem I used variadic templates (C++11) and template variables (C++14). We start by generating a map that associates the types, I use template variables:

template <typename ENUM>
std::map<ENUM, const std::string> nombre_enum{};

template <typename ENUM>
std::map<const std::string, ENUM> valor_enum{};

template <typename ENUM1, typename ENUM2>
std::map<ENUM1, ENUM2> asocia{};

With these template variables declared, we add some initialization functions:

void nombra() {}

template <typename ENUM, typename ... args>
void nombra(const ENUM value, const char *name, args ... tail)
{
    nombre_enum<ENUM>.emplace(value, name);
    valor_enum<ENUM>.emplace(name, value);
    nombra<ENUM>(tail ...);
}

void sincroniza() {}

template <typename ENUM1, typename ENUM2, typename ... args>
void sincroniza(const ENUM1 value1, const ENUM2 value2, args ... tail)
{
    asocia<ENUM1, ENUM2>.emplace(value1, value2);
    sincroniza(tail ...);
}

With these initialization functions ¹ , we must configure the system:

int main()
{
    nombra
    (
        Enum1::A,         "Doce",
        Enum1::B,         "Cuatro",
        Enum1::C,         "Cinco",
        Enum2::NoValue,   "Sin valor",
        Enum2::A,         "Uno",
        Enum2::B,         "Dos",
        Enum2::C,         "Tres",
        Enum2::MaxValues, "Máximo de Enum2"
    );

    sincroniza
    (
        Enum1::A, Enum2::A,
        Enum1::B, Enum2::B,
        Enum1::C, Enum2::C
    );
    return 0;
}

And this allows us to change the functions ToString, FromStringand Convertas follows:

template <typename ENUM>
std::string ToString(ENUM valor)
{
    std::string result{};
    auto found = nombre_enum<ENUM>.find(valor);

    if (found != nombre_enum<ENUM>.end()) result = found->second;

    return result;
}

template <typename ENUM>
ENUM FromString(std::string const& nombre)
{
    ENUM result{};
    auto found = valor_enum<ENUM>.find(nombre);

    if (found != valor_enum<ENUM>.end()) result = found->second;
    else throw std::runtime_error("valor no valido");

    return result;
}

template <typename ENUM1, typename ENUM2>
ENUM1 Convert(ENUM2 value)
{
    ENUM1 result{};
    auto found = asocia<ENUM2, ENUM1>.find(value);

    if (found != asocia<ENUM2, ENUM1>.end()) result = found->second;
    else throw std::runtime_error("valor no valido");

    return result;
}

And in consequence:

ToString(Enum1::A);        // Devuelve la cadena "Doce".
FromString<Enum1>("Doce"); // Devuelve Enum1::A.
FromString<Enum2>("Doce"); // Lanza una excepcion.
Convert<Enum1>(Enum2::A);  // Lanza una excepcion.
Convert<Enum2>(Enum1::A);  // Devuelve Enum2::A.

You can see the code working in Wandbox 三へ( へ՞ਊ ՞)へ ﾊｯﾊｯ.

Pros and cons.

Pro : Using template variables the compiler itself takes care of synchronizing the maps nombre_enum, valor_enumand asociabetween each translation unit . In fact, there will be only one copy for each type or combination of types used in the template, this is due to C++'s single definition rule and how this rule works with templates, according to the C++ standard (highlight and translation mine) :

3.2 Single definition rule

5. Exactly one definition of a class is required in a translation unit if that class is used in such a way that its type needs to be complete.

   [...]

6. There can be more than one type definition of a class (Clause 9), enumerated type (7.2), externally linked inline function (7.1.2), template class (Clause 14), non-static template function (14.5.6) , member data of a template class (14.5.1.3), member function of a template class (14.5.1.1), or template specialization for which some template parameters are not specified (14.7, 14.5.5) in a program in which each definition appears in different translation units , [...]

   [...]

   If D is a template and is defined in more than one translation unit, [...], then it will behave as if there is only one definition of D .

Con : The previous point implies that each of the template variables behaves like a global variable and its use in multithreaded code can be dangerous. But a priori, after the call to nombraand sincronizathere is no need to write any more to the maps, so use them via ToString, FromStringand Convertit would be read-only.

Pro : At the time of inserting new values ​​to the enumerations, the need for changes has been reduced from 4 (the enumeration and the functions ToString, FromStringand Convert) to 3 (the enumeration and the customization point in nombraand sincroniza).

¹ In C++17 we can save the empty recursion break function by using the constant conditional if constexpr:

template <typename ENUM, typename ... args>
void nombra(const ENUM value, const char *name, args ... tail)
{
    nombre_enum<ENUM>.emplace(value, name);
    valor_enum<ENUM>.emplace(name, value);

    if constexpr (sizeof...(tail) >= 2)
    {
        nombra<ENUM>(tail ...);
    }
}

template <typename ENUM1, typename ENUM2, typename ... args>
void sincroniza(const ENUM1 value1, const ENUM2 value2, args ... tail)
{
    asocia<ENUM1, ENUM2>.emplace(value1, value2);

    if constexpr (sizeof...(tail) >= 2)
    {
        sincroniza(tail ...);
    }
}

The first step is to create a new file, for example, valores.defand we move the enumerated values ​​to said file:

A = 12,
B = 4,
C = 5,

Now we edit that file to enclose each value in a macro. To avoid future errors, we define a base implementation of said macro and its subsequent cleaning:

#ifndef VALOR
#define VALOR(X,Y)
#endif

VALOR(A,12)
VALOR(B,4)
VALOR(C,5)

#undef VALOR

Now we generate the enumerations from said file. To do this, simply configure the macro at your convenience:

enum class Enum1
{
  #define VALOR(X,Y) X=Y,
  #include "valores.def"
};

enum class Enum2
{
  NoValue,
  #define VALOR(X,Y) X,
  #include "valores.def"
  MaxValues
};

And the same for the utility battery:

std::string ToString(Enum1 valor)
{
  switch( valor )
  {
    #define VALOR(X,Y) case Enum1::##X: return #X;
    #include "valores.def"
  }

  return "";
}

Enum1 FromString(std::string const& valor)
{
  #define VALOR(X,Y) if( valor == #X ) return Enum1::##X;
  #include "valores.def"

  throw std::runtime_exception("valor no valido");
}

Enum1 Convert(Enum2 value)
{
  switch( value )
  {
    #define VALOR(X,Y) case Enum2::##X: return Enum1::##X;
    #include "valores.def"
  }

  throw std::runtime_exception("valor no valido");
}

Advantages of this system:

• The enumerated ones can be in different files.
• Utilities require no maintenance
• By using macros, the content of valores.defcan be as versatile as we want, being able to contain text, comments, etc...
• Compatible with old C++ standards

One option is to use the preprocessor. Modifying your example:

#define LISTA(X, S) \
X(A, 12) S \
X(B, 4) S \
X(C, 5)

#define COMA ,

// Este enumerado necesita los valores porque se almacenan en la base de datos
enum class Enum1
{
#define X(A, B) A = B
LISTA(X, COMA)
#undef X
};

// Este enumerado es necesario para realizar tareas de iteración
// y porque si :)
enum class Enum2
{
  NoValue,
#define X(A, B) A,
LISTA(X, )
#undef X
  MaxValues
};

// Convierte cada etiqueta en su representación a string
std::string ToString(Enum1 valor)
{
  switch( valor )
  {
#define X(A, B) case Enum1::A: return #A;
LISTA(X, )
#undef X
  }

  return "";
}

Enum1 FromString(std::string const& valor)
{
#define X(A, B) if (valor == #A) return Enum1::A;
LISTA(X, )
#undef X

  throw std::runtime_exception("valor no valido");
}

Enum1 Convert(Enum2 value)
{
  switch( value )
  {
#define X(A, B) case Enum2::A: return Enum1::A;
LISTA(X, )
#undef X
  }

  throw std::runtime_exception("valor no valido");
}