Optionally activating a constructor in a templated class - c++

Question

Let's suppose we have this class:
class MyEnumClass
{
public:
enum Type
{
Example0,
Count
};
using EnumType = Type;
};
And this one.
class MyEnumClass2
{
public:
enum Type2
{
Example0,
Count
};
};
And we want to handle something related to it in a different class. But this class also supports other different than MyEnumClass classes, MyEnumClass2 is included too and have not same members. The classes are not meant to be touched at all. So I want it to be copy constructible from its instantiable classes:
template<typename T, typename U>
class EnumClassHandler
{
public:
EnumClassHandler() : value(0) {}
// Here want to make an optional copy constructor
EnumClassHandler(const T::EnumType& value)
{
// Do whatever
}
// This class should also be supported
EnumClassHandler(const T::Type2& value)
{
//Do whatever
}
U value;
};
I would like this EnumClassHandler to support this:
typedef EnumClassHandler<MyEnumClass, uint32_t> MyEnumClassHandler;
typedef EnumClassHandler<MyEnumClass2, uint32_t> MyEnumClass2Handler;
int main()
{
MyEnumClassHandler example = MyEnumClass::Example0;
MyEnumClass2Handler example2 = MyEnumClass2::Example0;
}
Here is the wandbox code reflecting the problem, which is that fails on instantiating non supported constructors for different classes.
How can I make EnumClassHandler support optionally copy constructible for those, and a bunch of similar to MyEnumClass and MyEnumClass2 classes(so modifying those internally is not allowed), in c++14?

Answer 1

To enable the constructor only for the respective T::EnumType or T::Type2 you can do this:
template<typename T, typename U>
class EnumClassHandler
{
public:
EnumClassHandler() : value(0) {}
// only viable when T has T::EnumType
template <typename W = T>
EnumClassHandler(const typename W::EnumType& value)
{
//Do whatever
}
// only viable when T has T::Type2
template <typename W = T>
EnumClassHandler(const typename W::Type2& value)
{
//Do whatever
}
U value;
};
This will make your code work, while this
MyEnumClass2Handler example3 = MyEnumClass::Example0;
results in error:
<source>:56:47: error: conversion from 'MyEnumClass::Type' to non-scalar type 'MyEnumClass2Handler' {aka 'EnumClassHandler<MyEnumClass2, unsigned int>'} requested
56 | MyEnumClass2Handler example3 = MyEnumClass::Example0;
| ~~~~~~~~~~~~~^~~~~~~~
Live Demo.
PS: If possible I would rather add an EnumType alias to each MyEnumClassX to keep that complexity out of the EnumClassHandler. If this isnt feasible, I would use a type trait:
template <typename MYENUMCLASS>
struct enum_type_from_myenumclass {
using type = typename MYENUMCLASS::EnumType;
};
You can specialize it for each MyEnumClass that does not have the EnumType member alias:
template <>
struct enum_type_from_myenumclass<MyEnumClass2> {
using type = typename MyEnumClass2::Type2;
};
// ... and similar for others ...
Then the EnumClassHandler only needs to use enum_type_from_myenumclass<T>::type and doesn't need to care about the differently named aliases.
Live Demo