How can I extend a lexical cast to support enumerated types?

by

You have to do two steps. Finding an integral type large enough to store the values. You could use unsigned long, but the values could be negative. Then you could use long but the values could extend into the range of unsigned long. So there is not really a fit-it-all type.

There is a trick though, by using overload resolution. Here is it

template<typename T>
struct id { typedef T type; };

id<char[1]>::type &find_etype(int);
id<char[2]>::type &find_etype(unsigned int);
id<char[3]>::type &find_etype(long);
id<char[4]>::type &find_etype(unsigned long);

You can change it appropriately to cover also long long or unsigned long long if your implementation has support for that. Now, passing an enum type will prefer one of these over all the other ones – that’s a type that can store all values of it. You just need to pass sizeof of the return type to some template. 

template<int> struct get_etype;
template<> struct get_etype<1> { typedef int type; };
template<> struct get_etype<2> { typedef unsigned int type; };
template<> struct get_etype<3> { typedef long type; };
template<> struct get_etype<4> { typedef unsigned long type; };

Now, you can get a right type. All you need now is to see whether some type is an enumeration. How to do this is described in the book “C++ Templates – The complete Guide”, and unfortunately is a whole lot of code. So i would use boost’s is_enum. Putting it together, it could look like

template <typename T>
typename boost::disable_if< boost::is_enum<T>, bool>::type 
ConvertString(const std::string& theString, T& theResult)
{
    std::istringstream iss(theString);
    return !(iss >> theResult).fail();
}

template <typename T>
typename boost::enable_if< boost::is_enum<T>, bool>::type 
ConvertString(const std::string& theString, T& theResult)
{
    typedef typename get_etype<sizeof find_etype(theResult)>::type 
      safe_type;

    std::istringstream iss(theString);
    safe_type temp;
    const bool isValid = !(iss >> temp).fail();
    theResult = static_cast<T>(temp);
    return isValid;
}

Hope this helps.

More Related Contents:

  1. Can I use the result of a comparison as an integer in C++?
  2. Regular cast vs. static_cast vs. dynamic_cast [duplicate]
  3. Multi-character constant warnings
  4. Is there a simple way to convert C++ enum to string?
  5. How to use enums as flags in C++?
  6. How can I iterate over an enum?
  7. What does casting to `void` really do? [duplicate]
  8. Can I assume (bool)true == (int)1 for any C++ compiler?
  9. Converting a pointer into an integer
  10. Serialization with Qt
  11. Base enum class inheritance
  12. Cast pointer to member function to normal pointer
  13. Allow for Range-Based For with enum classes?
  14. Reinterpret_cast vs. C-style cast
  15. Serialization of struct
  16. C++ auto vs auto&
  17. Passing shared_ptr as shared_ptr
  18. How to use C++11 enum class for flags
  19. Why cast a pointer to a float into a pointer to a long, then dereference?
  20. Why doesn’t this reinterpret_cast compile?
  21. c++ Read/Write class from/to binary file
  22. what is the size of an enum type data in C++?
  23. namespaces for enum types – best practices
  24. Do C++ enums Start at 0?
  25. Why must an enumeration’s size be provided when it is forward declared?
  26. Should I use a C++ reinterpret_cast over a C-style cast?
  27. Get private data members for non intrusive boost serialization C++
  28. how to do performance test using the boost library for a custom library
  29. Why Doesn’t reinterpret_cast Force copy_n for Casts between Same-Sized Types?
  30. How to cast simple pointer to a multidimensional-array of fixed size?

Leave a Comment