00001 #ifndef __REGISTRAR_H 00002 #define __REGISTRAR_H 00003 00004 #include <iostream> 00005 #include <map> 00006 #include <string> 00007 #include <assert.h> 00008 00013 namespace Teem 00014 { 00037 template<typename T, typename IdT, typename Arg1T = void, typename Arg2T = void> class Registrar 00038 { 00039 public: 00041 template<typename Sub> void registerItem(const IdT &id) 00042 { 00043 mItems[id] = &Creator<Sub>; 00044 } 00045 00047 T* createItem(const IdT &id, Arg1T arg1, Arg2T arg2) 00048 { 00049 if (mItems.find(id) == mItems.end()) 00050 { 00051 std::cerr << "Class of type " << id << " unregistred, aborting.\n\nKnown classes are:\n"; 00052 dump(std::cerr); 00053 std::cerr << std::endl; 00054 exit(1); 00055 } 00056 return mItems[id](arg1, arg2); 00057 } 00058 00060 void dump(std::ostream &stream) 00061 { 00062 for (typename std::map<IdT, CreatorFunc>::iterator it = mItems.begin(); it != mItems.end(); ++it) 00063 stream << "* " << it->first << "\n"; 00064 } 00065 00066 protected: 00068 typedef T* (*CreatorFunc)(Arg1T, Arg2T); 00069 std::map<IdT, CreatorFunc> mItems; 00070 00072 template<typename Sub> static T* Creator(Arg1T arg1, Arg2T arg2) 00073 { 00074 return new Sub(arg1, arg2); 00075 } 00076 }; 00077 00100 template<typename T, typename IdT, typename ArgT> class Registrar<T, IdT, ArgT, void> 00101 { 00102 public: 00104 template<typename Sub> void registerItem(const IdT &id) 00105 { 00106 mItems[id] = &Creator<Sub>; 00107 } 00108 00110 T* createItem(const IdT &id, ArgT arg) 00111 { 00112 if (mItems.find(id) == mItems.end()) 00113 { 00114 std::cerr << "Class of type " << id << " unregistred, aborting.\n\nKnown classes are:\n"; 00115 dump(std::cerr); 00116 std::cerr << std::endl; 00117 exit(1); 00118 } 00119 return mItems[id](arg); 00120 } 00121 00123 void dump(std::ostream &stream) 00124 { 00125 for (typename std::map<IdT, CreatorFunc>::iterator it = mItems.begin(); it != mItems.end(); ++it) 00126 stream << "* " << it->first << "\n"; 00127 } 00128 00129 protected: 00131 typedef T* (*CreatorFunc)(ArgT); 00132 std::map<IdT, CreatorFunc> mItems; 00133 00135 template<typename Sub> static T* Creator(ArgT arg) 00136 { 00137 return new Sub(arg); 00138 } 00139 }; 00140 00163 template<typename T, typename IdT> class Registrar<T, IdT, void, void> 00164 { 00165 public: 00167 template<typename Sub> void registerItem(const IdT &id) 00168 { 00169 mItems[id] = &Creator<Sub>; 00170 } 00171 00173 T* createItem(const IdT &id) 00174 { 00175 if (mItems.find(id) == mItems.end()) 00176 { 00177 std::cerr << "Class of type " << id << " unregistred, aborting.\n\nKnown classes are:\n"; 00178 dump(std::cerr); 00179 std::cerr << std::endl; 00180 exit(1); 00181 } 00182 return mItems[id](); 00183 } 00184 00186 void dump(std::ostream &stream) 00187 { 00188 for (typename std::map<IdT, CreatorFunc>::iterator it = mItems.begin(); it != mItems.end(); ++it) 00189 stream << "* " << it->first << "\n"; 00190 } 00191 00192 protected: 00194 typedef T* (*CreatorFunc)(); 00195 std::map<IdT, CreatorFunc> mItems; 00196 00198 template<typename Sub> static T* Creator() 00199 { 00200 return new Sub(); 00201 } 00202 }; 00203 } 00204 00205 #endif