00001
00002
00003 #ifndef INCLUDED_WMclass_h_
00004 #define INCLUDED_WMclass_h_
00005
00006 #include <string>
00007 #include <vector>
00008 #include <iostream>
00009 #include "Events/EventRouter.h"
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054 #define WM_max_stringlen 60
00055
00056 class WMentry;
00057 class WMitem_base;
00058
00059
00060
00061
00062 class WMregistry {
00063 public:
00064 std::string name;
00065 std::vector<WMentry*> entries;
00066 bool watched;
00067 WMregistry* parent;
00068
00069 public:
00070
00071 WMregistry(const std::string &n = "anonymous", WMregistry* p=NULL) : name(n), entries(), watched(0), parent(p) {};
00072 WMregistry(const WMregistry& in) : name(in.name), entries(in.entries), watched(in.watched), parent(in.parent) {}
00073
00074
00075 WMregistry& operator=(const WMregistry& in) {
00076 name=in.name;
00077 entries=in.entries;
00078 watched=in.watched;
00079 parent=in.parent;
00080 return *this;
00081 }
00082
00083
00084 void watch(void) { watched = 1; };
00085
00086
00087 void unwatch(void) { watched = 0; };
00088
00089
00090 void dump(void) const;
00091
00092 };
00093
00094
00095
00096
00097
00098
00099
00100 class WMentry {
00101 public:
00102 std::string const item_name;
00103 std::string const type_name;
00104 WMitem_base* const item;
00105 WMregistry* registry;
00106 bool watched;
00107
00108 public:
00109
00110 WMentry(const std::string &iname, const std::string &tname, WMitem_base* ival, WMregistry* reg = 0) :
00111 item_name(iname), type_name(tname), item(ival), registry(reg), watched(0) {};
00112 WMentry(const WMentry& in) : item_name(in.item_name), type_name(in.type_name), item(in.item), registry(in.registry), watched(in.watched) {}
00113
00114 private:
00115 WMentry operator=(const WMentry&);
00116 };
00117
00118
00119
00120
00121
00122 class WMitem_base {
00123 public:
00124 virtual ~WMitem_base() {}
00125 void* const value;
00126 WMentry* entry;
00127 virtual std::string toString(void) const = 0;
00128
00129
00130 WMitem_base(void* const val) : value(val), entry(NULL) {};
00131 WMitem_base(const WMitem_base &in ) : value(in.value), entry(in.entry) {}
00132
00133
00134 void watch(void) const {
00135 entry->watched = 1;
00136 erouter->postEvent(new EventBase(EventBase::wmVarEGID,reinterpret_cast<unsigned int>(entry),EventBase::activateETID));
00137 };
00138
00139
00140 void unwatch(void) const {
00141 entry->watched = 0;
00142 erouter->postEvent(new EventBase(EventBase::wmVarEGID,reinterpret_cast<unsigned int>(entry),EventBase::deactivateETID));
00143 };
00144
00145 private:
00146 WMitem_base& operator=(const WMitem_base & );
00147 };
00148
00149
00150
00151
00152
00153
00154
00155 template<class T>
00156 class WMitem : public WMitem_base {
00157 public:
00158 WMitem(T* const initval) : WMitem_base(initval) {}
00159 WMitem(const WMitem& in) : WMitem_base(in) {}
00160
00161 virtual WMitem<T>& operator= (const T &new_value);
00162 WMitem<T>& operator++ ();
00163 WMitem<T> operator++ (int);
00164 WMitem<T>& operator-- ();
00165 WMitem<T> operator-- (int);
00166 WMitem<T>& operator+= (const T &val);
00167 WMitem<T>& operator-= (const T &val);
00168 WMitem<T>& operator*= (const T &val);
00169 WMitem<T>& operator/= (const T &val);
00170
00171
00172 void announce (const T &val);
00173
00174
00175 virtual T& get_value(void) const { return *static_cast<T*>(value); };
00176
00177
00178 virtual operator T&() const { return *static_cast<T*>(value); };
00179
00180
00181 virtual std::string toString(void) const;
00182 };
00183
00184
00185
00186
00187
00188 #define WMvar(T,name) \
00189 static WMitem<T> name(lookup_WMentry<T>(#name,#T,GlobalWM));
00190
00191
00192 #define WMvari(T,name,initval) \
00193 static WMitem<T> name(lookup_WMentry<T>(#name,#T,initval,GlobalWM));
00194
00195
00196 #define WMvar_(T,name,registry) \
00197 static WMitem<T> name(lookup_WMentry<T>(#name,#T,registry));
00198
00199
00200 #define WMvari_(T,name,initval,registry) \
00201 static WMitem<T> name(lookup_WMentry<T>(#name,#T,initval,registry));
00202
00203
00204 #define WMreg(name) \
00205 static WMitem<WMregistry> name(lookup_reg(#name,GlobalWM));
00206
00207
00208 #define WMreg_(name,parent) \
00209 static WMitem<WMregistry> name(lookup_reg(#name,parent));
00210
00211
00212
00213
00214
00215
00216
00217
00218
00219 template<typename T>
00220 WMitem<T> lookup_WMentry(const std::string &iname,
00221 const std::string &tname,
00222 const std::string ®name);
00223
00224 template<typename T>
00225 WMitem<T> lookup_WMentry(const std::string &iname,
00226 const std::string &tname,
00227 const WMregistry ®);
00228
00229 template<typename T>
00230 WMitem<T> lookup_WMentry(const std::string &iname,
00231 const std::string &tname,
00232 const T &initval, WMregistry ®);
00233
00234 template<typename T>
00235 WMitem<T> create_WMentry(const std::string &iname,
00236 const std::string &tname,
00237 const T* const value, WMregistry ®);
00238
00239
00240 extern WMregistry GlobalWM;
00241
00242 WMitem<WMregistry> lookup_reg(const std::string &name, WMregistry ®istry);
00243
00244 void dump(const WMitem<WMregistry> &wmreg);
00245
00246
00247
00248
00249
00250 template<class T>
00251 std::string WMitem<T>::toString(void) const {
00252 char print_buffer[30];
00253 sprintf(print_buffer,"%x",reinterpret_cast<unsigned int>(value));
00254 return "<" + entry->type_name + " at 0x" + print_buffer + ">";
00255 }
00256
00257
00258
00259
00260 template<class T>
00261 WMitem<T>& WMitem<T>::operator= (const T &new_value) {
00262 get_value() = new_value;
00263
00264 announce (new_value);
00265 return *this;
00266 }
00267
00268 template<class T>
00269 void WMitem<T>::announce (const T&) {
00270 if (entry->watched) {
00271 erouter->postEvent(new EventBase(EventBase::wmVarEGID,reinterpret_cast<unsigned int>(entry),EventBase::statusETID));
00272 }
00273
00274
00275
00276
00277
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289 }
00290
00291 template<class T>
00292 WMitem<T>& WMitem<T>::operator++ (void) {
00293 announce(++get_value());
00294 return *this;
00295 }
00296
00297 template<class T>
00298 WMitem<T> WMitem<T>::operator++ (int) {
00299 WMitem<T> temp(*this);
00300 announce(++get_value());
00301 return temp;
00302 }
00303
00304 template<class T>
00305 WMitem<T>& WMitem<T>::operator-- (void) {
00306 announce(--get_value());
00307 return *this;
00308 }
00309
00310 template<class T>
00311 WMitem<T> WMitem<T>::operator-- (int) {
00312 WMitem<T> temp(*this);
00313 announce(--get_value());
00314 return temp;
00315 }
00316
00317 template<class T>
00318 WMitem<T>& WMitem<T>::operator+= (const T &val) {
00319 return operator=(get_value()+val);
00320 }
00321
00322 template<class T>
00323 WMitem<T>& WMitem<T>::operator-= (const T &val) {
00324 return operator=(get_value()-val);
00325 }
00326
00327 template<class T>
00328 WMitem<T>& WMitem<T>::operator*= (const T &val) {
00329 return operator=(get_value()*val);
00330 }
00331
00332 template<class T>
00333 WMitem<T>& WMitem<T>::operator/= (const T &val) {
00334 return operator=(get_value()/val);
00335 }
00336
00337
00338
00339
00340
00341
00342
00343
00344
00345 template<typename T>
00346 WMitem<T> lookup_WMentry(const std::string &iname,
00347 const std::string &tname,
00348 const std::string ®name) {
00349 WMregistry* reg = 0;
00350 for (std::vector<WMentry*>::const_iterator it = GlobalWM.entries.begin(); it != GlobalWM.entries.end(); it++) {
00351 if ( (*it)->item_name == regname ) {
00352 reg = static_cast<WMregistry*>((*it)->item->value);
00353 break;
00354 };
00355 };
00356 if ( reg == 0 ) {
00357 reg = new WMregistry(regname, &GlobalWM);
00358 create_WMentry(regname, "WMregistry", reg, GlobalWM);
00359 };
00360 return lookup_WMentry<T>(iname, tname, *reg);
00361 }
00362
00363 template<typename T>
00364 WMitem<T> lookup_WMentry(const std::string &iname,
00365 const std::string &tname,
00366 WMregistry ®) {
00367 for (std::vector<WMentry*>::const_iterator it = reg.entries.begin(); it != reg.entries.end(); it++) {
00368 if ( (*it)->item_name == iname )
00369 return *static_cast<WMitem<T> const*>((*it)->item);
00370 };
00371 return create_WMentry(iname, tname, new T, reg);
00372 }
00373
00374 template<typename T>
00375 WMitem<T> lookup_WMentry(const std::string &iname,
00376 const std::string &tname,
00377 T const &initval, WMregistry ®) {
00378 for (std::vector<WMentry*>::const_iterator it = reg.entries.begin(); it != reg.entries.end(); it++) {
00379 if ( (*it)->item_name == iname )
00380 return *static_cast<WMitem<T> const*>((*it)->item);
00381 };
00382 return create_WMentry(iname, tname, new T(initval), reg);
00383 }
00384
00385 template<typename T>
00386 WMitem<T> create_WMentry(const std::string &iname,
00387 const std::string &tname,
00388 T* const value, WMregistry ®) {
00389 WMentry* new_entry = new WMentry(iname, tname, new WMitem<T>(value), ®);
00390 new_entry->item->entry = new_entry;
00391 reg.entries.push_back(new_entry);
00392 return *static_cast<WMitem<T> const*>(new_entry->item);
00393 }
00394
00395 #endif
00396