Consider a alias template declaration, depending on a single template parameter that can have a finite number of values, like a class enum.
I would like to a employ using to define a type alias for every value of the class enum.
One way of implementing is to use std::conditional:
class enum color { white, red, blue };
struct A {};
struct B {};
struct C {};
template <color c>
using data = std::conditional_t<c == color::white, A, std::conditional_t<c == color::red, B, C>>;
Obviously, when the class enum color is expanded to new values, one needs an additional nested std::conditional, which is rather cumbersome.
I am looking for a solution to express this in a "scalable" way, that is, such that on expanding the class enum one has to do a minimal work.
Something like
template <class c>
using data = some_struct<c, A, B, C>;
where some_struct "select" the type A, B, C depending on the first parameter c.
How can I implement that (in a scalable way)?
One way you can do this is to create a tuple of the types to pick from and match those up with the order of the enum you have. Then you can just get the type from the tuple at the index of the value of the enumeration. That would look like
using type_set = std::tuple<A, B, C>;
template <color c>
using data_t = typename std::tuple_element<static_cast<size_t>(c), type_set>::type;
Now all you need to do is add types to the tuple that defines type_set as you add enumerations to color. You can see it working in this live example which uses an error message to tell you what data_t<color::red> resolves to the type B.