named_object_list.h

   1 #ifndef NAMED_OBJECT_LIST_H
   2 #define NAMED_OBJECT_LIST_H
   3
   4 #include <map>
   5 #include <string>
   6
   7 // Define an associative container that maps a name with a class and a
   8 // description.  All classes must be derived from a same base class.
   9 //
  10 // We can then use the name to create an object of the associated
  11 // class, and to retrieve a pointer to this object.
  12 //
  13 // Furthermore, it is possible to iterate over the elements to get
  14 // their name and their description.
  15
  16 // I am too lazy to comment the code, which should be obvious...
  17
  18 //===== arity 0 =====
  19
  20 template <typename Base>
  21 class named_object_list {
  22 protected:
  23     struct creator_base {
  24         std::string description;
  25         creator_base(const std::string& descr): description(descr) { }
  26         creator_base(const char* descr): description(descr) { }
  27         virtual Base* operator()() const = 0;
  28     };
  29
  30     template <typename Derived>
  31     struct creator: public creator_base {
  32         creator(const std::string& descr): creator_base(descr) { }
  33         creator(const char* descr): creator_base(descr) { }
  34         Base* operator()() const { return new Derived(); }
  35     };
  36
  37     typedef std::map<std::string, const creator_base*> map_type;
  38
  39     map_type assoc;
  40
  41     void insert(const std::string& name, const creator_base* creat)
  42     {
  43         assoc.insert(std::make_pair(name, creat));
  44     }
  45
  46     void insert(const char* name, const creator_base* creat)
  47     {
  48         assoc.insert(std::make_pair(std::string(name), creat));
  49     }
  50
  51 public:
  52     typedef typename map_type::const_iterator iterator;
  53
  54     named_object_list() { };
  55     ~named_object_list()
  56     {
  57         for (iterator it = begin(); it != end(); ++it)
  58             delete it->second;
  59     }
  60
  61     Base* new_instance(const std::string& name) const
  62     {
  63         iterator it = assoc.find(name);
  64         if (it != assoc.end())
  65             return (*it->second)();
  66         else
  67             return NULL;
  68     }
  69
  70     Base* new_instance(const char* name) const
  71     {
  72         return new_instance(std::string(name));
  73     }
  74
  75     const std::string& get_name(iterator& it) const { return it->first; }
  76     const std::string& get_descr(iterator& it) const
  77     { return it->second->description; }
  78
  79     bool exists(const std::string& name) const
  80     { return assoc.find(name) != assoc.end(); }
  81     iterator begin() const       { return assoc.begin(); }
  82     iterator end() const         { return assoc.end();   }
  83
  84 };
  85
  86 //===== arity 2 =====
  87
  88 template <typename Base, typename Arg1, typename Arg2>
  89 class named_object_list2 {
  90 protected:
  91     struct creator_base {
  92         std::string description;
  93         creator_base(const std::string& descr): description(descr) { }
  94         creator_base(const char* descr): description(descr) { }
  95         virtual Base* operator()(Arg1, Arg2) const = 0;
  96     };
  97
  98     template <typename Derived>
  99     struct creator: public creator_base {
 100         creator(const std::string& descr): creator_base(descr) { }
 101         creator(const char* descr): creator_base(descr) { }
 102         Base* operator()(Arg1 arg1, Arg2 arg2) const
 103         { return new Derived(arg1, arg2); }
 104     };
 105
 106     typedef std::map<std::string, const creator_base*> map_type;
 107
 108     map_type assoc;
 109
 110     void insert(const std::string& name, const creator_base* creat)
 111     {
 112         assoc.insert(std::make_pair(name, creat));
 113     }
 114
 115     void insert(const char* name, const creator_base* creat)
 116     {
 117         assoc.insert(std::make_pair(std::string(name), creat));
 118     }
 119
 120 public:
 121     typedef typename map_type::const_iterator iterator;
 122
 123     named_object_list2() { };
 124     ~named_object_list2()
 125     {
 126         for (iterator it = begin(); it != end(); ++it)
 127             delete it->second;
 128     }
 129
 130     Base* new_instance(const std::string& name, Arg1 arg1, Arg2 arg2) const
 131     {
 132         iterator it = assoc.find(name);
 133         if (it != assoc.end())
 134             return (*it->second)(arg1, arg2);
 135         else
 136             return NULL;
 137     }
 138
 139     Base* new_instance(const char* name, Arg1 arg1, Arg2 arg2) const
 140     {
 141         return new_instance(std::string(name), arg1, arg2);
 142     }
 143
 144     const std::string& get_name(iterator& it) const { return it->first; }
 145     const std::string& get_descr(iterator& it) const
 146     { return it->second->description; }
 147
 148     bool exists(const std::string& name) const
 149     { return assoc.find(name) != assoc.end(); }
 150     iterator begin() const       { return assoc.begin(); }
 151     iterator end() const         { return assoc.end();   }
 152
 153 };
 154
 155 //===================
 156
 157 // "NOL" like in Named_Object_List....
 158 #define NOL_INSERT(name, descr, class) insert(name, new creator<class>(descr))
 159
 160 #endif // !NAMED_OBJECT_LIST_H
 161
 162 // Local variables:
 163 // mode: c++
 164 // End: