ConsecutiveEnumFactory.h

Go to the documentation of this file.

#ifndef _utl_ConsecutiveEnumFactory_h_
#define _utl_ConsecutiveEnumFactory_h_

#include <utl/AugerException.h>
#include <utl/ThrowPolicy.h>

#include <sstream>


namespace utl {

  template<
    typename EnumType,
    EnumType last,
    const char* const tags[],
    class NoConversionPolicy = ThrowPolicy<EnumType, utl::IOFailureException>,
    EnumType first = static_cast<EnumType>(0)
  >
  class ConsecutiveEnumFactory {
    template<typename T>
    static
    EnumType
    Handle(const T& t)
    {
      std::ostringstream os;
      os << "Cannot convert " << t << " to any of the valid enumerators:";
      for (unsigned int i = 0; i < kNumEnum; ++i)
        os << ' ' << tags[i];
      os << " (with values from " << first << " to " << last << ").";
      return NoConversionPolicy::Handle(os.str());
    }
  public:
    const static unsigned int kNumEnum = last - first + 1;
    static
    EnumType
    Create(const int k)
    {
      if (first <= k && k <= last)
        return static_cast<EnumType>(k);
      return Handle(k);
    }
    static
    EnumType
    Create(const std::string& tag)
    {
      // This linear search may be replaced by a more sophisticated
      // look-up strategy, but for this case it does not seem worth of
      // it. In fact, given a (supposed) typical quantity of (at most)
      // 10 enumerators, this simple loop could not be outperformed
      // (even discarding some initialization procedures that may
      // be needed).
      // Even more, who would be able to quantify the difference given
      // that number of values!
      for (unsigned int i = 0; i < kNumEnum; ++i)
        if (tags[i] == tag)
          return static_cast<EnumType>(i);
      return Handle(tag);
    }
  };

}


#endif