/ps/src/dsc/co/mw/mwfwk/cmwfwList.cc Source File

00001 #include "cmwfwList.h"
00002 #include "cmwfwTypes.h"
00003 #include "cmwfwDoorKeeper.h"
00004 
00005 class cmwfwIOValue;
00006 class cmwfwTgmBitPattern;
00007 class cmwfwTgmExclusive;
00008 class cmwfwTgmNumericValue;
00009 
00010 //The following statements serves to avoid linker errors like:
00011 //list_tst.o(.pr+0x60):list_tst.cc:
00012 //undefined reference to `ListClass<int>::insert(int)'
00013 //list_tst.o(.pr+0xd0):list_tst.cc:
00014 //undefined reference to `ListClass<int>::showme(void)'
00015 
00016 //Some compiler option for instanciating templates
00017 //needs to be activated
00018 #if ( defined(__GNUC__) || defined(_MSC_VER) )
00019 template class cmwfwList<cmwfwIOPoint*>;
00020 //template class cmwfwList<char>;
00021 //template class cmwfwList<int>;
00022 template class cmwfwList<cmwfwIOValue*>;
00023 template class cmwfwList<cmwfwTgmExclusive*>;
00024 template class cmwfwList<cmwfwTgmBitPattern*>;
00025 template class cmwfwList<cmwfwTgmNumericValue*>;
00026 template class cmwfwList<cmwfwValueChangeListener*>;
00027 #endif
00028 
00029 
00030 #define FILE "source file:cmwfwList.cc"
00031 #define ID "Contact Steen JENSEN, PS/CO"
00032 #define PROGRAM "Middleware server framework"
00033 #define T(a,b,c,d,e) TRACE(a,"%s(%s): %s %s %s %s\n",myname,FILE,b,c,d,e)
00034 #define E(a,b,c,d) ERROR("%s:%s(%s):ERROR: %s %s %s %s - %s\n",PROGRAM,myname,FILE,a,b,c,d,ID)
00035 //T(CMWFW_TRACE_,"","","","");
00036 //E("","","","");
00037 
00038 
00043 template<class T>
00044 ListWrapperClass<T>::ListWrapperClass(T input){
00045   char* myname = "ListWrapperClass<T>::ListWrapperClass";
00046   T(CMWFW_TRACE_CALLS,"Entering","","","");
00047 
00048   data=input;
00049   next=prev=0;
00050 
00051   T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00052 };
00053 
00054 
00055 
00060 template<class T>
00061 T ListWrapperClass<T>::Data(){
00062   char* myname = "ListWrapperClass<T>::Data";
00063   T(CMWFW_TRACE_CALLS,"Entering","","","");
00064 
00065   T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00066   return(data);
00067 };
00068 
00069 
00070 
00080 template<class T>
00081 cmwfwList<T>::cmwfwList(bool thr_safe){
00082   char* myname = "cmwfwList<T>::cmwfwList";
00083   T(CMWFW_TRACE_CALLS,"Entering","","","");
00084 
00085   size=0;
00086   first=last=0;
00087   thread_safe = thr_safe;
00088   if(thread_safe == true){
00089     doorkeeper  = new cmwfwDoorKeeper;
00090     if(!doorkeeper)heaperr(84);
00091   }
00092   else{
00093     doorkeeper  = 0;
00094   };
00095 
00096   T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00097 };
00098 
00099 
00110 template<class T>
00111 cmwfwList<T>::~cmwfwList(){
00112   char* myname = "cmwfwList<T>::~cmwfwList";
00113   T(CMWFW_TRACE_CALLS,"Entering","","","");
00114 
00115   ListWrapperClass<T>* tmp1 = first;
00116   ListWrapperClass<T>* tmp2 = 0;
00117 
00118   while(tmp1){
00119     tmp2 = tmp1->next;
00120     delete tmp1;
00121     tmp1 = tmp2;
00122   };
00123   
00124   if(doorkeeper)
00125     delete doorkeeper;
00126 
00127   T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00128 };
00129 
00130 
00131 
00132 
00142 template<class T>
00143 void cmwfwList<T>::Size(int* sz,bool useMutex){ //cannot simply return the size 
00144   char* myname = "cmwfwList<T>::Size";                  //because of mutex
00145   T(CMWFW_TRACE_CALLS,"Entering","","","");
00146 
00147   cmwfwDoorKeeperLock lock(*doorkeeper);
00148 
00149   if( (useMutex) && (thread_safe) )             //When this method returns,
00150         lock.activate();                                    //lock goes out of scope,
00151                                                                                                 //and the doorkeeper is unlocked
00152   *sz = size;
00153 
00154   T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00155 };
00156 
00157 
00167 template<class T>
00168 bool cmwfwList<T>::getFirst(T* dest,bool useMutex){
00169   char* myname = "cmwfwList<T>::getFirst";
00170   T(CMWFW_TRACE_CALLS,"Entering","","","");
00171 
00172   cmwfwDoorKeeperLock lock(*doorkeeper);
00173 
00174   if( (useMutex) && (thread_safe) )
00175         lock.activate();
00176 
00177   if(first){
00178     *dest = first->Data();
00179     T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00180     return true;
00181   };
00182   T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00183   return false;
00184 };
00185 
00186 
00187 
00197 template<class T>
00198 bool cmwfwList<T>::getLast(T* dest,bool useMutex){
00199   char* myname = "cmwfwList<T>::getLast";
00200   T(CMWFW_TRACE_CALLS,"Entering","","","");
00201 
00202   cmwfwDoorKeeperLock lock(*doorkeeper);
00203 
00204    if( (useMutex) && (thread_safe) )
00205         lock.activate();
00206 
00207   if(!last){
00208     T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00209     return false;
00210   };
00211 
00212   *dest = last->Data();
00213 
00214   T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00215   return true;
00216 };
00217 
00218 
00228 template<class T>
00229 bool cmwfwList<T>::getNext(T* dest,T pos,bool useMutex){
00230   char* myname = "cmwfwList<T>::getNext";
00231   T(CMWFW_TRACE_CALLS,"Entering","","","");
00232 
00233   cmwfwDoorKeeperLock lock(*doorkeeper);
00234 
00235   if( (useMutex) && (thread_safe) )
00236         lock.activate();
00237 
00238   ListWrapperClass<T>* tmp = first;
00239   while( (!(tmp->Data() == pos)) && tmp)
00240     tmp = tmp->next;
00241   if(!tmp){
00242     T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00243     return false;
00244   };
00245 
00246   *dest = tmp->Data();
00247 
00248   T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00249   return true;
00250 };
00251 
00252 
00262 template<class T>
00263 bool cmwfwList<T>::getNext(T* dest,bool useMutex){
00264   char* myname = "cmwfwList<T>::getNext";
00265   T(CMWFW_TRACE_CALLS,"Entering","","","");
00266 
00267   ListWrapperClass<T>* tmp = 0;
00268   cmwfwDoorKeeperLock lock(*doorkeeper);
00269 
00270   if( (useMutex) && (thread_safe) )
00271         lock.activate();
00272 
00273   if(current){
00274     tmp = current->next;
00275     current = tmp;
00276   };
00277   if(!tmp){
00278     T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00279     return false;
00280   };
00281 
00282   *dest = tmp->Data();
00283 
00284   T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00285   return true;
00286 };
00287 
00288 
00298 template<class T>
00299 bool cmwfwList<T>::getPrev(T* dest,T pos,bool useMutex){
00300   char* myname = "cmwfwList<T>::getPrev";
00301   T(CMWFW_TRACE_CALLS,"Entering","","","");
00302 
00303   cmwfwDoorKeeperLock lock(*doorkeeper);
00304 
00305   if( (useMutex) && (thread_safe) )
00306         lock.activate();
00307 
00308   ListWrapperClass<T>* tmp = first;
00309   while( (!(tmp->Data() == pos)) && tmp)
00310     tmp = tmp->next;
00311 
00312   if(!tmp){
00313     T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00314         return false;
00315   };
00316 
00317   *dest = tmp->Data();
00318 
00319   T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00320   return true;
00321 };
00322 
00323 
00333 template<class T>
00334 bool cmwfwList<T>::getPrev(T* dest,bool useMutex){
00335   char* myname = "cmwfwList<T>::getPrev";
00336   T(CMWFW_TRACE_CALLS,"Entering","","","");
00337 
00338   ListWrapperClass<T>* tmp = 0;
00339   cmwfwDoorKeeperLock lock(*doorkeeper);
00340 
00341 
00342   if( (useMutex) && (thread_safe) )
00343         lock.activate();
00344 
00345   if(current){
00346     tmp = current->prev;
00347     current = tmp;
00348   };
00349   if(!tmp){
00350     T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00351         return false;
00352   };
00353 
00354   *dest = tmp->Data();
00355 
00356   T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00357   return true;
00358 };
00359 
00360 
00370 template<class T>
00371 bool cmwfwList<T>::getCurrent(T* dest,bool useMutex){
00372   char* myname = "cmwfwList<T>::getCurrent";
00373   T(CMWFW_TRACE_CALLS,"Entering","","","");
00374 
00375   cmwfwDoorKeeperLock lock(*doorkeeper);
00376 
00377   if( (useMutex) && (thread_safe) )
00378         lock.activate();
00379 
00380   if(!current){
00381     T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00382     return false;
00383   };
00384 
00385   *dest = current->Data();
00386 
00387   T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00388   return true;
00389 };
00390 
00391 
00401 template<class T>
00402 bool cmwfwList<T>::get(T& item, T* dest,bool useMutex){
00403 //Only makes sense when looking for a type (class)
00404 //that is overloading the == operator
00405   char* myname = "cmwfwList<T>::get";
00406   T(CMWFW_TRACE_CALLS,"Entering","","","");
00407 
00408   cmwfwDoorKeeperLock lock(*doorkeeper);
00409   bool found = false;
00410   ListWrapperClass<T>* tmp = first;
00411 
00412   if( (useMutex) && (thread_safe) )
00413         lock.activate();
00414 
00415   while( (tmp) && (found==false) ){
00416     if(tmp->Data()==item){
00417       found=true;
00418     };
00419     if(found==false)
00420       tmp = tmp->next;
00421   };
00422   if(tmp)
00423     *dest = tmp->Data();
00424 
00425   T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00426   return found;
00427 };
00428 
00429 
00430 
00431 
00441 template<class T>
00442 void cmwfwList<T>::resetCurrent(bool useMutex){
00443   char* myname = "cmwfwList<T>::resetCurrent";
00444   T(CMWFW_TRACE_CALLS,"Entering","","","");
00445 
00446   cmwfwDoorKeeperLock lock(*doorkeeper);
00447 
00448   if( (useMutex) && (thread_safe) )
00449         lock.activate();
00450 
00451   current = first;
00452 
00453   T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00454 };
00455 
00456 
00466 template<class T>
00467 bool cmwfwList<T>::insert(T item,bool useMutex){
00468   char* myname = "cmwfwList<T>::insert";
00469   T(CMWFW_TRACE_CALLS,"Entering","","","");
00470 
00471   int sz = 0;
00472   int found = 0;
00473   ListWrapperClass<T>* lwc = 0;
00474   ListWrapperClass<T>* tmp_lwc = 0;
00475   cmwfwDoorKeeperLock lock(*doorkeeper);
00476 
00477 
00478   if( (useMutex) && (thread_safe) )
00479         lock.activate();
00480 
00481   if( (!first) && (!last) ){
00482     lwc = new ListWrapperClass<T>(item);
00483     if(!lwc)heaperr(431);
00484     lwc->prev = 0;
00485     lwc->next = 0;
00486     first=last=lwc;
00487     size = 1;
00488     T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00489     return true;
00490   };
00491 
00492   tmp_lwc = first;
00493   while( (tmp_lwc) && (!(tmp_lwc->Data() == item)) ){//So that only == operator 
00494     tmp_lwc = tmp_lwc->next;                                     //needs to be overloaded
00495   };
00496   if(!tmp_lwc){                                      //Insert new item in list
00497     lwc = new ListWrapperClass<T>(item);
00498     if(!lwc)heaperr(446);
00499     lwc->next = first;
00500     lwc->prev = 0;
00501     first->prev = lwc;
00502     first=lwc;
00503     size++;
00504     T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00505     return true;
00506   };
00507 
00508   T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00509   return false;
00510 };
00511 
00512 
00513 
00523 template<class T>
00524 bool cmwfwList<T>::remove(T item,bool useMutex){
00525   char* myname = "cmwfwList<T>::remove";
00526   T(CMWFW_TRACE_CALLS,"Entering","","","");
00527 
00528   int sz = 0;
00529   ListWrapperClass<T>* tmp;
00530   cmwfwDoorKeeperLock lock(*doorkeeper);
00531 
00532 
00533   if( (useMutex) && (thread_safe) )
00534         lock.activate();
00535 
00536   tmp = first;
00537         
00538   while( (tmp) && (!(tmp->Data() == item)) ) //So that only == operator
00539     tmp = tmp->next;                                             //needs to be overloaded
00540 
00541   if(tmp){
00542     if( (!tmp->prev) && (!tmp->next) ){      //Last item in list
00543       size = 0;
00544       first=last=0;
00545     }
00546     else if( (!tmp->prev) && (tmp->next) ){  //First item in list
00547       first=tmp->next;
00548       first->prev=0;
00549       size--;
00550     }
00551     else if( (tmp->prev) && (tmp->next) ){   //Item somewhere in list,
00552       tmp->next->prev = tmp->prev;           //not first nor last
00553       tmp->prev->next = tmp->next;
00554       size--;
00555     }
00556     else if( (tmp->prev) && (!tmp->next) ){  //Last item in list
00557       tmp->prev->next = 0;
00558       last = tmp->prev;
00559       size--;
00560     };
00561     delete tmp;
00562     T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00563     return true;
00564   };
00565 
00566   T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00567   return false;
00568 };
00569 
00570 
00571 
00572 
00573 
00584 template<class T>
00585 bool cmwfwList<T>::hasItem(T item,bool useMutex){
00586   char* myname = "cmwfwList<T>::hasItem";
00587   T(CMWFW_TRACE_CALLS,"Entering","","","");
00588 
00589   bool found = false;
00590   ListWrapperClass<T>* tmp = first;
00591   cmwfwDoorKeeperLock lock(*doorkeeper);
00592 
00593   if( (useMutex) && (thread_safe) )
00594         lock.activate();
00595 
00596   while( (tmp) && (found==false) ){
00597     if(tmp->Data()==item){
00598       found=true;
00599     };
00600     tmp = tmp->next;
00601   };
00602 
00603   T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00604   return found;
00605 };
00606 
00607 
00608 
00609 
00610 
00611 template<class T>
00612 void cmwfwList<T>::heaperr(int line){
00613   char* myname = "cmwfwList";
00614   T(CMWFW_TRACE_CALLS,"Entering","","","");
00615 
00616   char l[30];
00617   itoa(line,l);
00618   E("Out of heap in line ",l,"","");
00619   T(CMWFW_TRACE_CALLS,"Exiting due to heap all","","","");
00620   throw cmwfwInternalError(FILE,line,"Out of heap memory");
00621   exit(-1);
00622 };
00623 
00624 
00625 
00637 /*
00638 template<class T>
00639 bool cmwfwList<T>::wait_getRemove(T* dest,timespec* timeout = 0){
00640   char* myname = "cmwfwList<T>::wait_getRemove";
00641 
00642 
00643   doorkeeper->getLock();
00644   while(size==0)
00645     doorkeeper->wait(timeout);
00646   ListWrapperClass<T>* tmp = last;
00647 
00648   if(tmp){
00649     if(!tmp->prev){//Last item in list
00650       size = 0;
00651       first=last=0;
00652     }
00653     else{
00654       tmp->prev->next = 0;
00655       last = tmp->prev;
00656       size--;
00657     };
00658     *dest = tmp->Data();
00659     delete tmp;
00660     doorkeeper->notify();
00661     doorkeeper->releaseLock();
00662     return true;
00663   };
00664   size = 0;
00665   doorkeeper->notify();
00666   doorkeeper->releaseLock();
00667   return false;
00668 };
00669 */
00670 
00671 
00672 
00682 template<class T>
00683 void cmwfwList<T>::lock(){
00684   char* myname = "cmwfwList<T>::lock";
00685   T(CMWFW_TRACE_CALLS,"Entering","","","");
00686 
00687   if (thread_safe)
00688         doorkeeper->getLock();
00689 
00690   T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00691 };
00692 
00693 
00694 
00695 
00705 template<class T>
00706 void cmwfwList<T>::unlock(){
00707   char* myname = "cmwfwList<T>::unlock";
00708   T(CMWFW_TRACE_CALLS,"Entering","","","");
00709 
00710   if (thread_safe) {
00711 //      doorkeeper->notify();
00712         doorkeeper->releaseLock();
00713   };
00714 
00715   T(CMWFW_TRACE_CALLS,"Returning - all ok","","","");
00716 };
00717 
00718