Bidirectional static value mapping in c++17 - c++

Question

I want to efficiently bidirectionally map some values of different types in C++17 (1:1 mapping of only very few values). Consider for example mapping enum values and integers, though the problem is applicable to other types as well. Currently, I'm doing it like this:
#include <optional>
enum class ExampleEnum { A, B, C, D, E };
class MyMapping {
public:
std::optional<int> enumToInt(ExampleEnum v) {
switch(v) {
case ExampleEnum::A:
return 1;
case ExampleEnum::B:
return 5;
case ExampleEnum::D:
return 42;
}
return std::nullopt;
}
std::optional<ExampleEnum> intToEnum(int v) {
switch(v) {
case 1:
return ExampleEnum::A;
case 5:
return ExampleEnum::B;
case 42:
return ExampleEnum::D;
}
return std::nullopt;
}
};
This has the obvious disadvantage of having to write everything twice, and forgetting to update one of the functions will lead to inconsistencies. Is there a better method?
I need:
Consistency. It shouldn't be possible to have different semantics in mapping and reverse mapping.
Compile-time definition. The values which are mapped are known in advance, and will not change at runtime.
Runtime lookup. Which values will be looked up is not known at compile-time, and may even not contain a mapping at all (returning an empty optional instead).
I would like to have:
No additional memory allocations
Basically the same performance as the double-switch-method
An implementation which makes the mapping definition easily extendable (i.e. adding more values in the future or applying it to other types)

Answer 1

I've given a shot to very naive and simple implementation. https://godbolt.org/z/MtcHw8
#include <optional>
enum class ExampleEnum { A, B, C, D, E };
template<typename Enum, int N>
struct Mapping
{
Enum keys[N];
int values[N];
constexpr std::optional<Enum> at(int x) const noexcept
{
for(int i = 0; i < N; i++)
if(values[i] == x) return keys[i];
return std::nullopt;
}
constexpr std::optional<int> at(Enum x) const noexcept
{
for(int i = 0; i < N; i++)
if(keys[i] == x) return values[i];
return std::nullopt;
}
};
constexpr Mapping<ExampleEnum, 3> mapping{{ExampleEnum::A, ExampleEnum::B, ExampleEnum::D},
{111, 222, 333}};
int main()
{
int x = rand(); // Force runtime implementation
auto optEnum = mapping.at(x);
if(optEnum.has_value())
return *mapping.at(ExampleEnum::B); // Returns 222, (asm line 3) constexpr works
auto y = (ExampleEnum)rand(); // Force runtime implementation
auto optInt = mapping.at(y);
if(optInt.has_value())
return (int)*mapping.at(333); // Returns 3, constexpr works
return 0;
}
It utilizes loop unrolling to achieve switch-method performance in int -> ExampleEnum mappings.
Assembly for ExampleEnum -> int mapping is quite obscure, as optimizer utilized the fact that enum values are sequenced and prefers jump table over if-else implementation.
Anyway, the interface requires no duplication, just create constexpr object with two arrays fed into construction. You can have multiple mappings for same types. Also, enum type is templated.
Also, it can be easily extended to support two enum class instead of only enum-int.
I've also created snipped with raw switch implementations for assembly comparison:
https://godbolt.org/z/CbEcnZ
PS. I believe syntax constexpr Mapping<ExampleEnum, 3> mapping could be simplified with proper template deduction guide, but I have not found out how to do it.
PPS. I went with N up to 15, loop unrolling is still on: https://godbolt.org/z/-Cpmgm

Answer 2

It will be better to avoid such code. They tend to violate one of the fundamental principles of software development, The Open-Closed Principle.
You can improve MyMapping by making it general. Let a higher level class/function define the mappings.
class MyMapping {
public:
void registerItem(ExampleEnum eValue, int intValue)
{
enumToIntMap[eValue] = intValue;
intToEnumMap[intValue] = eValue;
}
std::optional<int> enumToInt(ExampleEnum v) {
auto iter = enumToIntMap.find(v);
if ( iter != enumToIntMap.end() )
{
return iter->second;
}
else
{
return std::nullopt;
}
}
std::optional<ExampleEnum> intToEnum(int v) {
auto iter = intToEnumMap.find(v);
if ( iter != intToEnumMap.end() )
{
return iter->second;
}
else
{
return std::nullopt;
}
}
std::map<ExampleEnum, int> enumToIntMap;
std::map<int, ExampleEnum> intToEnumMap;
};
A higher level function can be:
void initMyMapping(MyMapping& mapping)
{
mapping.registerItem(A, 1);
mapping.registerItem(B, 2);
mapping.registerItem(D, 42);
}
I understand that this still violates the open-closed principle but to a lesser degree. If you want to add mapping data for C and E, you'll have to add code for that. However, you can do that without changing MyMapping. You also have the option of doing that in a second function, and not change initMyMapping.
void initMyMapping_extend(MyMapping& mapping)
{
mapping.registerItem(C, 22);
mapping.registerItem(E, 38);
}