fail proof conversion of string to enum class - c++

Question

I have an enum class like this (I am planning to add more options to it later):
enum class ViSequencePointType {
JumpToValue = 0,
RampToValue = 1
};
Then I have a configuration text file which each line supposed to represents one the enum values. Something like this:
1
0
255
A
WTF
I need to parse this file and create a vector of that enum class...so I do something like:
bool conversionResult = false;
int colThree = line.toInt(&conversionResult);
if(!conversionResult) {
//failed to convert to integer
} else {
ViSequencePointType pt = static_cast<ViSequencePointType>(colThree);
switch(pt) {
case ViSequencePointType::JumpToValue:
break;
case ViSequencePointType::RampToValue:
break;
default:
break;
}
for that default case the compiler says
Default label in switch which covers all enumeration values
which I believe it means if there is any invalid entry in the text file exists, I can not find it out!
So how can I approach this problem without letting any invalid enumeration slip through during runtime?

Answer 1

In order to cover invalid/nonsensical enum values, a common practice is to
rely on the fact subsequent enum values are implicitly assigned the value of the previous enum value + 1
add an "Invalid" enum value at the lowest value in the enum (implicitly 0, or you can assign it a low value such as -1)
add a "Max" enum value at the highest value in the enum
Here's an example:
enum class ViSequencePointType
{
Invalid = -1,
JumpToValue, // is implicitly assigned enum value 0 (-1 + 1 == 0)
RampToValue, // is implicitly 1 (JumpToValue + 1)
CrawlToValue, // etc...
HopToValue,
// add new values here
Max // Max must be the last value in the enum
};
Now when you parse your input value you can check the integral value is greater than Invalid and less than Max, and if so, you know it's a valid enum value
ViSequencePointType parse(const std::string& value)
{
bool converted = false;
int val = line.toInt(&converted);
if(!converted)
{
// do additional conversion failure handling here if necessary
return ViSequencePointType::Invalid;
}
if (val <= static_cast<int>(ViSequencePointType::Invalid) ||
val >= static_cast<int>(ViSequencePointType::Max)
{
// do additional out of bounds handling here if necessary
return ViSequencePointType::Invalid;
}
return static_cast<ViSequencePointType>(val);
}
Now you know the output from parse is a valid enum value, with the output for unknown/invalid values denoted by enum value Invalid.