C++11 metaprogramming - lookup enum value during compilation (values contains gaps) - c++

Question

Is there a way, at compile-time, to verify that a given
value is within the values of a given enum, thus valid?
enum myenum { val1 = 10, val2 = 30, val3 = 45 }
template <myenum t>
class myClass
{ ... }
myClass<10> a; // fails, OK
myClass<val1> b; // compiles OK
myClass<myenum(24)> c; //compiles, NOT OK!
Using a second template non-type boolean parameter would be useful in there, and the value of that boolean would be given by a meta-function, that given a value would verify that the value is within the values of myenum.
I looked through various enum related question, like how to iterate an enum, and it seems it can't be done.

Answer 1

enum myenum { val1 = 10, val2 = 30, val3 = 45 };
template<myenum e> struct is_valid_myenum { static const bool value = (e==val1 || e==val2 || e==val3); };
template<myenum t>
class myClass
{
static_assert(is_valid_myenum<t>::value, "t must be a valid enum value");
};
myClass<10> a; // fails, OK
myClass<val1> b; // compiles OK
myClass<myenum(24)> c; // fails, OK
If you really, really want to avoid the duplication (and aren't interested in using some external tool to generate sourcecode) you can resort to macro hackery.
#define LIST \
ITEM(val1,10)\
ITEM(val2,30)\
ITEM(val3,45)
#define ITEM(NAME,VALUE) NAME = VALUE,
enum myenum { LIST };
#undef ITEM
#define ITEM(NAME,VALUE) e==NAME ||
template<myenum e> struct is_valid_myenum { static const bool value = ( LIST false ); };
template<myenum t>
class myClass
{
static_assert(is_valid_myenum<t>::value, "t must be a valid enum value");
};
myClass<10> a; // fails, OK
myClass<val1> b; // compiles OK
myClass<myenum(24)> c; // fails, OK

Answer 2

You can never prevent other developers to shoot in their own foot. You can never win. Just ensure your API does not make it easy.
If he takes an invalid value, casts it, and then passes it to you, it is purely his problem. This is the same kind of problem as if you provide him a function taking a pointer of type T* as parameter, but he takes some random data (of arbitrary type), casts it to T* and passes it in.
That's how casting works: The person who does the cast is responsible to guarantee that the casted expression can be safely interpreted as value of the type he casts to.

Answer 3

Short of redeclaring all your information in metaprogramming form, it cannot be done. However, you could for instance do:
enum myenum { val1 = 10, val2 = 30, val3 = 45 };
typedef vector_c< myenum, val1, val2, val3 > typed_myenum;
typedef
contains< typed_myenum, integral_c< myenum, val >::value
val_found;
Using functionality from Boost.MPL, although the actual syntax might be a bit off.

Answer 4

There are no ways to check that a value is within a valid range of an enum at run time, less at compile time.
The only way to check is to brute force check for every value. Something like this:
enum lala
{
A = 10,
B = 20,
C = 30
};
template< int value >
struct T
{
static_assert( (value == A) || (value == B ) || (value == C), "wrong value" );
};
int main()
{
T< 10 > t10;
T< 20 > t20;
T< 25 > t25;
T< 30 > t30;
(void)t10;(void)t20;(void)t25;(void)t30;
}

Answer 5

If the enum's name is not important for you, maybe you can just transfer it to an array, such as:
const int myenum[]={10,30,45}
then use an index to reference them from the myenum.
template<unsigned int t>
class myClass
{
static_assert(t < sizeof(myenum)/sizeof(int), "t must be a valid enum index");
int val=myenum[t];
...
};