mapnik::enumeration< ENUM, THE_MAX > Class Template Reference

#include <enumeration.hpp>

List of all members.

Public Types

enum Max { MAX = THE_MAX }

typedef ENUM native_type

Public Member Functions

enumeration ()

enumeration (ENUM v)

enumeration (const enumeration &other)

void operator= (ENUM v)

void operator= (const enumeration &other)

operator ENUM () const

ENUM max () const

void from_string (const std::string &str)

std::istream & parse (std::istream &is)

std::string as_string () const

std::ostream & print (std::ostream &os=std::cerr) const

Static Public Member Functions

static const char * get_string (unsigned i)

static bool verify (const char *filename, unsigned line_no)

static const std::string & get_full_qualified_name ()

static std::string get_name ()

Related Functions

(Note that these are not member functions.)

template<class ENUM, int THE_MAX>

std::ostream & operator<< (std::ostream &os, const mapnik::enumeration< ENUM, THE_MAX > &e)

template<class ENUM, int THE_MAX>

std::istream & operator>> (std::istream &is, mapnik::enumeration< ENUM, THE_MAX > &e)

DEFINE_ENUM(name, e)

IMPLEMENT_ENUM(name, strings)

Detailed Description

template<class ENUM, int THE_MAX>
class mapnik::enumeration< ENUM, THE_MAX >

Slim wrapper for enumerations. It creates a new type from a native enum and a char pointer array. It almost exactly behaves like a native enumeration type. It supports string conversion through stream operators. This is usefull for debugging, serialization/deserialization and also helps with implementing language bindings. The two convinient macros DEFINE_ENUM() and IMPLEMENT_ENUM() are provided to help with instanciation.

Limitations:

The enum must start at zero.
The enum must be consecutive.
The enum must be terminated with a special token consisting of the enum's name plus "_MAX".
The corresponding char pointer array must be terminated with an empty string.
The names must only consist of characters and digits (a-z, A-Z, 0-9), underscores (_) and dashes (-).

Warning:: At the moment the verify() method is called during static initialization. It quits the application with exit code 1 if any error is detected. The other solution i thought of is to do the checks at compile time (using boost::mpl).

Example:

The following code goes into the header file:

 enum fruit_enum {
      APPLE,
      CHERRY,
      BANANA,
      PASSION_FRUIT,
      fruit_enum_MAX
 };

 static const char * fruit_strings[] = {
      "apple",
      "cherry",
      "banana",
      "passion_fruit",
      ""
 };

 DEFINE_ENUM( fruit, fruit_enum);

In the corresponding cpp file do:

 IMPLEMENT_ENUM( fruit, fruit_strings );

And here is how to use the resulting type Fruit

 int
 main(int argc, char * argv[]) {
      fruit f(APPLE);
      switch ( f ) {
          case BANANA:
          case APPLE:
              cerr << "No thanks. I hate " << f << "s" << endl;
              break;
          default:
              cerr << "Hmmm ... yummy " << f << endl;
              break;
      }
      
      f = CHERRY;

      fruit_enum native_enum = f;
      
      f.from_string("passion_fruit");

      for (unsigned i = 0; i < fruit::MAX; ++i) {
          cerr << i << " = " << fruit::get_string(i) << endl;
      }

      f.from_string("elephant"); // throws illegal_enum_value

      return 0;
 }