Setting enumerated values based on string representions - c++

Question

I have a config file containing string representations of an enum. There are a lot of different enum values. After loading the config, I need to work out enum values from it string representations. Ignoring macros, the only way I can think of doing this would be to create a hideous lookup function doing a string comparison against every possible value. Something like:
typedef enum Fields
{
FieldFlagNone,
FieldFlagOperation,
FieldFlagFormat,
...
}
Fields getFieldEnum(string fieldName){
if( fieldName.compare("FieldFlagNone") == 0 ){
return FieldFlagNone;
}else if( fieldName.compare("FieldFlagOperation") == 0 ){
return FieldFlagOperation;
}else if( fieldName.compare("FieldFlagFormat") == 0 ){
return FieldFlagFormat;
...
}
Is there a faster or more concise way of achieving the desired result?

Answer 1

You can use std::unordered_map<std::string, Fields>, that will speed up the conversion from linear time to constant time:
std::unordered_map<std::string, Fields> fieldsLookupTable {
{ "FieldFlagNone", FieldFlagNone },
...
};
To make it more concise you can use some macros:
#define LOOKUP_TABLE_ENTRY(x) { #x, x }
And then:
std::unordered_map<std::string, Fields> fieldsLookupTable {
LOOKUP_TABLE_ENTRY(FieldFlagNone),
LOOKUP_TABLE_ENTRY(FieldFlagOperation),
...
};
If you want to go really hardcore on eliminating duplication, you can do something like this:
#define ENUM_MODE_DEFINE 0
#define ENUM_MODE_LOOKUP 1
#define ENUM_BEGIN(x) \
#if ENUM_MODE == ENUM_MODE_DEFINE \
typedef enum x { \
#else \
#define LOOKUP_TABLE_NAME x ## LookupTable \
std::unordered_map<std::string, x> LOOKUP_TABLE_NAME; \
#endif
#define ENUM_ENTRY(x) \
#if ENUM_MODE == ENUM_MODE_DEFINE \
x, \
#else \
LOOKUP_TABLE_NAME[#x] = x; \
#endif
#define ENUM_END \
#if ENUM_MODE == ENUM_MODE_DEFINE \
} \
#else \
#undef LOOKUP_TABLE_NAME \
#endif
And then define your enum like this:
#define FIELDS \
ENUM_BEGIN(Fields) \
ENUM_ENTRY(FieldFlagNone) \
ENUM_ENTRY(FieldFlagOperation) \
...
ENUM_END
And where previously there was the enum definition, now there will be this:
#define ENUM_MODE ENUM_MODE_DEFINE
FIELDS
And somewhere else where you had the lookup table, you say this:
#define ENUM_MODE ENUM_MODE_LOOKUP
FIELDS
Basically the FIELDS macro uses the ENUM_BEGIN, ENUM_ENTRY and ENUM_END macros, which generate different code based on the value of ENUM_MODE. If you define it to be ENUM_MODE_DEFINE, then FIELDS will generate the enum definition. If you set it to ENUM_MODE_LOOKUP, it'll generate fieldsLookupTable.
This way we only used the enum entry names in FIELDS, so if you change something there, the lookup table and the enum definition will change automatically and won't go out of sync.