tjhandler_code.h Source File

00001 #include <tjutils/tjhandler.h>
00002 #include <tjutils/tjlog.h>
00003 
00004 
00006 
00007 template<class I>
00008 Handled<I>::Handled() {}
00009 
00010 template<class I>
00011  Handled<I>::~Handled() {
00012     Log<HandlerComponent> odinlog("Handled","~Handled");
00013     for(typename STD_list< const Handler<I>* >::const_iterator it=handlers.begin(); it!=handlers.end(); ++it) {
00014       (*it)->handled_remove(this); // do not call L::remove here because it will modify handlers list
00015     }
00016   }
00017 
00018 
00019 template<class I>
00020   const  Handled<I>& Handled<I>::set_handler(const Handler<I>& handler) const {
00021     handlers.push_back(&handler);
00022     return *this;
00023   }
00024 
00025 template<class I>
00026   const  Handled<I>& Handled<I>::erase_handler(const Handler<I>& handler) const {
00027     handlers.remove(&handler);
00028     return *this;
00029   }
00030 
00031 
00033 
00034 
00035 template<class I>
00036   Handler<I>::Handler() {
00037     handledobj=0;
00038   }
00039 
00040 template<class I>
00041   Handler<I>::Handler(const Handler& handler) {
00042     Handler<I>::operator = (handler);
00043   }
00044 
00045 template<class I>
00046   Handler<I>& Handler<I>::operator = (const Handler& handler) {
00047     clear_handledobj();
00048     I hd=handler.get_handled();
00049     if(hd) set_handled(hd);
00050     return *this;
00051   }
00052 
00053 
00054 template<class I>
00055   Handler<I>::~Handler() {
00056     Log<HandlerComponent> odinlog("Handler","~Handler");
00057     clear_handledobj();
00058   }
00059 
00060 template<class I>
00061   const Handler<I>& Handler<I>::clear_handledobj() const {
00062     Log<HandlerComponent> odinlog("Handler","clear_handledobj");
00063     ODINLOG(odinlog,normalDebug) << "handledobj=" << (void*)handledobj << STD_endl;
00064     if(handledobj) handledobj->Handled<I>::erase_handler(*this);
00065     handledobj=0;
00066     return *this;
00067   }
00068 
00069 template<class I>
00070   const Handler<I>& Handler<I>::set_handled(I handled) const {
00071     Log<HandlerComponent> odinlog("Handler","set_handled");
00072     ODINLOG(odinlog,normalDebug) << "handled=" << (void*)handled << STD_endl;
00073     clear_handledobj();
00074     handled->Handled<I>::set_handler(*this);
00075     handledobj=handled;
00076     return *this;
00077   }
00078 
00079 
00080 
00081 template<class I>
00082   I Handler<I>::get_handled() const {
00083     return handledobj;
00084   }
00085 
00086 
00087 template<class I>
00088   const Handler<I>& Handler<I>::handled_remove(Handled<I>* handled) const {
00089     Log<HandlerComponent> odinlog("Handler","handled_remove");
00090     I handledtype=static_cast<I>(handled);
00091     ODINLOG(odinlog,normalDebug) << "handledtype=" << (void*)handledtype << STD_endl;
00092     if(handledtype) handledobj=0;
00093     else ODINLOG(odinlog,errorLog) << "Unable to remove handled!" << STD_endl;
00094     return *this;
00095   }
00096 
00100 
00101 
00102 
00103 template<class T, bool thread_safe>
00104   void SingletonHandler<T,thread_safe>::init (const char* unique_label) {
00105     // NOTE:  Debug uses SingletonHandler -> do not use Debug in here
00106     singleton_label=new STD_string;
00107     mutex=0;
00108     if(thread_safe) mutex=new Mutex();
00109     (*singleton_label)=unique_label;
00110     if(!get_external_map_ptr(unique_label)) {
00111       ptr=new T;
00112       ptr->set_label(unique_label);
00113       (*get_singleton_map())[unique_label]=this; // make sure singleton_map is allocated
00114     } else {
00115       ptr=0;
00116     }
00117   }
00118 
00119 template<class T, bool thread_safe>
00120   void SingletonHandler<T,thread_safe>::destroy () {
00121     if(ptr) delete ptr; ptr=0;
00122     delete singleton_label;
00123    if(mutex) delete mutex;
00124   }
00125 
00126 template<class T, bool thread_safe>
00127   void SingletonHandler<T,thread_safe>::copy(T& destination) const {
00128     T* p=get_map_ptr();
00129     if(p) destination=(*p);
00130   }
00131 
00132 
00133 template<class T, bool thread_safe>
00134   T* SingletonHandler<T,thread_safe>::get_map_ptr() const {
00135     if(ptr) return ptr; // fast return without touching the map
00136     if(singleton_map_external) {
00137       T* ext_ptr=(T*)get_external_map_ptr(*singleton_label);
00138       if(ext_ptr) ptr=ext_ptr;
00139     }
00140     return ptr;
00141   }