Homepage Demos Overview Downloads Tutorials Reference
Credits

EventRouter.cc

Go to the documentation of this file.
00001 #include "EventRouter.h"
00002 #include "Shared/Profiler.h"
00003 #include <algorithm>
00004 
00005 EventRouter * erouter=NULL;
00006 
00007 EventRouter::EventRouter()
00008   : timers(), events(), doSendBufferLock(false), lastBufClear(0), buffertime(0), trappers(), listeners()
00009 {}
00010 
00011 //! @todo handle recursive calls
00012 void EventRouter::processTimers() {
00013   //    cout << "processTimers..." << flush;
00014   unsigned int curtime=get_time();
00015   if(curtime-lastBufClear>=buffertime || buffertime==1)
00016     processEventBuffer();
00017 
00018   TimerEntry curTimer(curtime);
00019   timer_it_t last_it=upper_bound(timers.begin(),timers.end(),&curTimer,TimerEntryPtrCmp());
00020   std::vector<TimerEntry*> process(timers.begin(),last_it); //copy these out for safe keeping
00021   for(timer_it_t it=process.begin(); it!=process.end(); it++) //increment the timers we're processing
00022     if((*it)->repeat)
00023       (*it)->next+=(*it)->delay;
00024     else
00025       (*it)->next=(unsigned int)-1;
00026   sort(timers.begin(),last_it,TimerEntryPtrCmp()); //re-sort the timers we're processing (at the beginning of timers)
00027   inplace_merge(timers.begin(),last_it,timers.end(),TimerEntryPtrCmp()); //now do a merge of the sorted processed stuff and the rest of the list (which is still sorted)
00028   //  if(process.size()>0) chkTimers();
00029   for(timer_it_t it=process.begin(); it!=process.end(); it++) // process the timers we say we're going to, can no longer assume anything about the state of the world
00030     (*it)->el->processEvent(EventBase(EventBase::timerEGID,(*it)->sid,EventBase::statusETID,(*it)->next));
00031   //  if(process.size()>0) chkTimers();
00032   static const TimerEntry deadTimer((unsigned int)-1); // matches all the dead ones as set in the incrementation phase
00033   last_it=lower_bound(timers.begin(),timers.end(),&deadTimer,TimerEntryPtrCmp()); //find the beginning of all the non-repeating timers we're clearing
00034   for(timer_it_t it=last_it; it!=timers.end(); it++) // delete all of them
00035     delete *it;
00036   timers.erase(last_it,timers.end()); //and then remove them from the timer list
00037   //  if(process.size()>0) chkTimers();
00038   //    cout << "done" << endl;
00039 }
00040 
00041 /*! timers are unique by EventListener and source ID - can't have two timers for the same el and sid\n
00042  *  a delay of 0 with repeating will cause an event to be sent at every opportunity, use sparingly\n
00043  *  a delay of -1U will call removeTimer() if it already exists, otherwise is ignored\n
00044  *
00045  *  To add a timer, you can also call addListener() with EventBase::timerEGID and the sid
00046  *  and delay (in the EventBase::duration field) - this method will simply cause this
00047  *  function to be called internally.
00048  *
00049  *  @param el the EventListener to send the timer event to
00050  *  @param sid the source ID to use on that event (if you need to send more info, send a pointer to a struct of your devising, typecasted as int)
00051  *  @param delay the delay between the first (and future) calls
00052  *  @param repeat set to true if you want to keep receiving this event, otherwise it will only send once */
00053 void EventRouter::addTimer(EventListener* el, unsigned int sid, unsigned int delay, bool repeat) {
00054   if(delay==-1U) {
00055     removeTimer(el,sid);
00056     return;
00057   }
00058   for(timer_it_t it=timers.begin(); it!=timers.end(); it++)
00059     if((*it)->el==el && (*it)->sid==sid) {
00060       (*it)->Set(delay,repeat);
00061       // now put that timer back into the correct place in the ordering (think before touching this! ;)
00062       if(it!=timers.begin() && (*it)->next<(*(it-1))->next)
00063         rotate(upper_bound(timers.begin(),it,*it,TimerEntryPtrCmp()),it,it+1);
00064       else if(it+1!=timers.end() && (*it)->next>(*(it+1))->next)
00065         rotate(it,it+1,lower_bound(it+1,timers.end(),*it,TimerEntryPtrCmp()));
00066       return;
00067     }
00068   //didn't find a pre-existing one
00069   TimerEntry * add=new TimerEntry(el,sid,delay,repeat);
00070   timers.insert(lower_bound(timers.begin(),timers.end(),add,TimerEntryPtrCmp()),add);
00071   //  chkTimers();
00072 }
00073 
00074 void EventRouter::removeTimer(EventListener* el) {
00075   for(timer_it_t it=timers.begin(); it!=timers.end(); it++)
00076     if((*it)->el==el) {
00077       delete *it;
00078       *it=NULL;
00079     }
00080   timers.erase(remove(timers.begin(),timers.end(),(const TimerEntry*)NULL),timers.end());
00081 }
00082 
00083 void EventRouter::removeTimer(EventListener* el, unsigned int sid) {
00084   for(timer_it_t it=timers.begin(); it!=timers.end(); it++)
00085     if((*it)->el==el && (*it)->sid==sid) {
00086       delete *it;
00087       timers.erase(it);
00088       return;
00089     }
00090 }
00091 
00092 void EventRouter::removeAllTimers() {
00093   for(timer_it_t it=timers.begin(); it!=timers.end(); it++)
00094     delete *it;
00095   timers.erase(timers.begin(),timers.end());
00096 }
00097 
00098 void EventRouter::addListener(EventListener* el, EventBase::EventGeneratorID_t egid) {
00099   bool hadListener=hasListeners(egid);
00100   listeners.addMapping(el,egid); 
00101   if(!hadListener)
00102     postEvent(new EventBase(EventBase::erouterEGID,egid,EventBase::activateETID));
00103   else
00104     postEvent(new EventBase(EventBase::erouterEGID,egid,EventBase::statusETID));
00105 }
00106 void EventRouter::addListener(EventListener* el, EventBase::EventGeneratorID_t egid, unsigned int sid) {
00107   bool hadListener=hasListeners(egid);
00108   for(unsigned int et=0; et<EventBase::numETIDs; et++)
00109     listeners.addMapping(el,egid,sid,(EventBase::EventTypeID_t)et);
00110   if(!hadListener)
00111     postEvent(new EventBase(EventBase::erouterEGID,egid,EventBase::activateETID));
00112   else
00113     postEvent(new EventBase(EventBase::erouterEGID,egid,EventBase::statusETID));
00114 }
00115 void EventRouter::addListener(EventListener* el, EventBase::EventGeneratorID_t egid, unsigned int sid, EventBase::EventTypeID_t etid) {
00116   bool hadListener=hasListeners(egid);
00117   listeners.addMapping(el,egid,sid,etid);
00118   if(!hadListener)
00119     postEvent(new EventBase(EventBase::erouterEGID,egid,EventBase::activateETID));
00120   else
00121     postEvent(new EventBase(EventBase::erouterEGID,egid,EventBase::statusETID));
00122 }
00123 void EventRouter::addListener(EventListener* el, const EventBase& e) {
00124   if(e.getGeneratorID()==EventBase::timerEGID)
00125     addTimer(el,e.getSourceID(),e.getDuration());
00126   else {
00127     bool hadListener=hasListeners(e.getGeneratorID());
00128     listeners.addMapping(el,e.getGeneratorID(),e.getSourceID(),e.getTypeID());
00129     if(!hadListener)
00130       postEvent(new EventBase(EventBase::erouterEGID,e.getGeneratorID(),EventBase::activateETID));
00131     else
00132       postEvent(new EventBase(EventBase::erouterEGID,e.getGeneratorID(),EventBase::statusETID));
00133   }
00134 }
00135 
00136 void EventRouter::removeListener(EventListener* el) {
00137   for(unsigned int eg=0; eg<EventBase::numEGIDs; eg++)
00138     removeListener(el,(EventBase::EventGeneratorID_t)eg);
00139 }
00140 void EventRouter::removeListener(EventListener* el, EventBase::EventGeneratorID_t egid) {
00141   if(egid==EventBase::timerEGID)
00142     removeTimer(el);
00143   else {
00144     if(!listeners.removeMapping(el,egid))
00145       return; //nothing was removed, don't want to clean up or throw an event
00146     listeners.clean(egid);
00147     if(!hasListeners(egid))
00148       postEvent(new EventBase(EventBase::erouterEGID,egid,EventBase::deactivateETID));
00149     else
00150       postEvent(new EventBase(EventBase::erouterEGID,egid,EventBase::statusETID));
00151   }
00152 }
00153 void EventRouter::removeListener(EventListener* el, EventBase::EventGeneratorID_t egid, unsigned int sid) {
00154   if(egid==EventBase::timerEGID)
00155     removeTimer(el,sid);
00156   else {
00157     unsigned int removed=0;
00158     for(unsigned int et=0; et<EventBase::numETIDs; et++)
00159       removed+=listeners.removeMapping(el,egid,sid,(EventBase::EventTypeID_t)et);
00160     if(!removed)
00161       return; //nothing was removed, don't want to clean up or throw an event
00162     listeners.clean(egid);
00163     if(!hasListeners(egid))
00164       postEvent(new EventBase(EventBase::erouterEGID,egid,EventBase::deactivateETID));
00165     else
00166       postEvent(new EventBase(EventBase::erouterEGID,egid,EventBase::statusETID));
00167   }
00168 }
00169 void EventRouter::removeListener(EventListener* el, EventBase::EventGeneratorID_t egid, unsigned int sid, EventBase::EventTypeID_t etid) {
00170   if(egid==EventBase::timerEGID) {
00171     if(etid==EventBase::statusETID)
00172       removeTimer(el,sid);
00173   } else {
00174     if(!listeners.removeMapping(el,egid,sid,etid))
00175       return; //nothing was removed, don't want to clean up or throw an event
00176     listeners.clean(egid);
00177     if(!hasListeners(egid))
00178       postEvent(new EventBase(EventBase::erouterEGID,egid,EventBase::deactivateETID));
00179     else
00180       postEvent(new EventBase(EventBase::erouterEGID,egid,EventBase::statusETID));
00181   }
00182 }
00183 void EventRouter::removeListener(EventListener* el, const EventBase& e) {
00184   if(e.getGeneratorID()==EventBase::timerEGID)
00185     removeTimer(el,e.getSourceID());
00186   else {
00187     if(!listeners.removeMapping(el,e.getGeneratorID(),e.getSourceID(),e.getTypeID()))
00188       return; //nothing was removed, don't want to clean up or throw an event
00189     listeners.clean(e.getGeneratorID());
00190     if(!hasListeners(e.getGeneratorID()))
00191       postEvent(new EventBase(EventBase::erouterEGID,e.getGeneratorID(),EventBase::deactivateETID));
00192     else
00193       postEvent(new EventBase(EventBase::erouterEGID,e.getGeneratorID(),EventBase::statusETID));
00194   }
00195 }
00196 
00197 void EventRouter::forgetListener(EventListener* el) {
00198   removeListener(el);
00199 }
00200 
00201 void EventRouter::addTrapper(EventTrapper* el, const EventBase& e) {
00202   bool hadListener=hasListeners(e.getGeneratorID());
00203   trappers.addMapping(el,e.getGeneratorID(),e.getSourceID(),e.getTypeID());
00204   if(!hadListener)
00205     postEvent(new EventBase(EventBase::erouterEGID,e.getGeneratorID(),EventBase::activateETID));
00206   else
00207     postEvent(new EventBase(EventBase::erouterEGID,e.getGeneratorID(),EventBase::statusETID));
00208 }
00209 /*! Note that since timers are not broadcast, they cannot be trapped.  Only the EventListener which requested the timer will receive that timer. */
00210 void EventRouter::addTrapper(EventTrapper* el, EventBase::EventGeneratorID_t egid) {
00211   bool hadListener=hasListeners(egid);
00212   trappers.addMapping(el,egid);
00213   if(!hadListener)
00214     postEvent(new EventBase(EventBase::erouterEGID,egid,EventBase::activateETID));
00215   else
00216     postEvent(new EventBase(EventBase::erouterEGID,egid,EventBase::statusETID));
00217 }
00218 /*! Note that since timers are not broadcast, they cannot be trapped.  Only the EventListener which requested the timer will receive that timer. */
00219 void EventRouter::addTrapper(EventTrapper* el, EventBase::EventGeneratorID_t egid, unsigned int sid) {
00220   bool hadListener=hasListeners(egid);
00221   for(unsigned int et=0; et<EventBase::numETIDs; et++)
00222     trappers.addMapping(el,egid,sid,(EventBase::EventTypeID_t)et);
00223   if(!hadListener)
00224     postEvent(new EventBase(EventBase::erouterEGID,egid,EventBase::activateETID));
00225   else
00226     postEvent(new EventBase(EventBase::erouterEGID,egid,EventBase::statusETID));
00227 }
00228 /*! Note that since timers are not broadcast, they cannot be trapped.  Only the EventListener which requested the timer will receive that timer. */
00229 void EventRouter::addTrapper(EventTrapper* el, EventBase::EventGeneratorID_t egid, unsigned int sid, EventBase::EventTypeID_t etid) {
00230   bool hadListener=hasListeners(egid);
00231   trappers.addMapping(el,egid,sid,etid);
00232   if(!hadListener)
00233     postEvent(new EventBase(EventBase::erouterEGID,egid,EventBase::activateETID));
00234   else
00235     postEvent(new EventBase(EventBase::erouterEGID,egid,EventBase::statusETID));
00236 }
00237 
00238 /*! Note that since timers are not broadcast, they cannot be trapped.  Only the EventListener which requested the timer will receive that timer. */
00239 void EventRouter::addTrapper(EventTrapper* el) {
00240   for(unsigned int eg=0; eg<EventBase::numEGIDs; eg++)
00241     addTrapper(el,(EventBase::EventGeneratorID_t)eg);
00242 }
00243 
00244 
00245 void EventRouter::removeTrapper(EventTrapper* el, const EventBase& e) {
00246   if(!trappers.removeMapping(el,e.getGeneratorID(),e.getSourceID(),e.getTypeID()))
00247     return; //nothing was removed, don't want to clean up or throw an event
00248   trappers.clean(e.getGeneratorID());
00249   if(!hasListeners(e.getGeneratorID()))
00250     postEvent(new EventBase(EventBase::erouterEGID,e.getGeneratorID(),EventBase::deactivateETID));
00251   else
00252     postEvent(new EventBase(EventBase::erouterEGID,e.getGeneratorID(),EventBase::statusETID));
00253 }
00254 void EventRouter::removeTrapper(EventTrapper* el, EventBase::EventGeneratorID_t egid) {
00255   if(!trappers.removeMapping(el,egid))
00256     return; //nothing was removed, don't want to clean up or throw an event
00257   trappers.clean(egid);
00258   if(!hasListeners(egid))
00259     postEvent(new EventBase(EventBase::erouterEGID,egid,EventBase::deactivateETID));
00260   else
00261     postEvent(new EventBase(EventBase::erouterEGID,egid,EventBase::statusETID));
00262 }
00263 void EventRouter::removeTrapper(EventTrapper* el, EventBase::EventGeneratorID_t egid, unsigned int sid) {
00264   int removed=0;
00265   for(unsigned int et=0; et<EventBase::numETIDs; et++)
00266     removed+=trappers.removeMapping(el,egid,sid,(EventBase::EventTypeID_t)et);
00267   if(!removed)
00268     return; //nothing was removed, don't want to clean up or throw an event
00269   trappers.clean(egid);
00270   if(!hasListeners(egid))
00271     postEvent(new EventBase(EventBase::erouterEGID,egid,EventBase::deactivateETID));
00272   else
00273     postEvent(new EventBase(EventBase::erouterEGID,egid,EventBase::statusETID));
00274 }
00275 void EventRouter::removeTrapper(EventTrapper* el, EventBase::EventGeneratorID_t egid, unsigned int sid, EventBase::EventTypeID_t etid) {
00276   if(!trappers.removeMapping(el,egid,sid,etid))
00277     return; //nothing was removed, don't want to clean up or throw an event
00278   trappers.clean(egid);
00279   if(!hasListeners(egid))
00280     postEvent(new EventBase(EventBase::erouterEGID,egid,EventBase::deactivateETID));
00281   else
00282     postEvent(new EventBase(EventBase::erouterEGID,egid,EventBase::statusETID));
00283 }
00284 
00285 void EventRouter::removeTrapper(EventTrapper* el) {
00286   for(unsigned int eg=0; eg<EventBase::numEGIDs; eg++)
00287     removeTrapper(el,(EventBase::EventGeneratorID_t)eg);
00288 }
00289 
00290 void EventRouter::processEventBuffer() { //clears buffered events
00291   if(events.size()>0)
00292     doSendBuffer();
00293 }
00294 void EventRouter::doSendBuffer() {
00295   if(doSendBufferLock) {
00296     std::cout << "*** WARNING recursive call to doSendBuffer()" << std::endl;
00297     return;
00298   }
00299   doSendBufferLock=true;
00300   unsigned int start=get_time();
00301   //  doSendEvent(EventBase(EventBase::eventRouterEGID,0,EventBase::activateETID,0));
00302   //important to use indexes instead of iterators in case the event listeners decide to post more events during processing
00303   for(unsigned int i=0; i<events.size(); i++) {
00304     doSendEvent(*events[i]);
00305     delete events[i];
00306   }
00307   events.erase(events.begin(),events.end());
00308   doSendBufferLock=false;
00309   lastBufClear=start;
00310   //  doSendEvent(EventBase(EventBase::eventRouterEGID,0,EventBase::deactivateETID,get_time()-start));
00311 }
00312 
00313 void EventRouter::processEvent(const EventBase& e) {
00314   // want to make sure we don't send events out of order...
00315   if(events.size()>0)
00316     doSendBuffer();
00317   doSendEvent(e);
00318 }
00319 void EventRouter::doSendEvent(const EventBase& e) {
00320   //  cout << "doSendEvent("<<e.getName()<<")..." << flush;
00321   std::vector<EventTrapper*> t;
00322   trappers.getMapping(e,t);
00323   for(std::vector<EventTrapper*>::iterator it=t.begin(); it!=t.end(); it++)
00324     if(trappers.verifyMapping(*it,e))
00325       if((*it)->trapEvent(e))
00326         return;
00327   std::vector<EventListener*> l;
00328   listeners.getMapping(e,l);
00329   for(std::vector<EventListener*>::iterator it=l.begin(); it!=l.end(); it++)
00330     if(listeners.verifyMapping(*it,e))
00331       (*it)->processEvent(e);
00332   //  cout << "done." << flush;
00333 }
00334 
00335 EventRouter::EventMapper::EventMapper() {
00336   for(unsigned int eg=0; eg<EventBase::numEGIDs; eg++)
00337     for(unsigned int et=0; et<EventBase::numETIDs; et++)
00338       filteredevents[eg][et]=NULL;
00339 }
00340 
00341 void EventRouter::EventMapper::addMapping(void* el, EventBase::EventGeneratorID_t egid, unsigned int sid, EventBase::EventTypeID_t etid) {
00342   if(filteredevents[egid][etid]==NULL) //if this is the first subscriber to this EGID and ETID
00343     filteredevents[egid][etid]=new SIDtoListenerVectorMap_t(); 
00344   SIDtoListenerVectorMap_t::iterator it=filteredevents[egid][etid]->find(sid); // now find subscribers to the source id as well
00345   std::vector<void*>* elv=NULL;
00346   if(it==filteredevents[egid][etid]->end()) { // if this is the first subscriber to the source ID
00347     std::pair<const unsigned int,std::vector<void*> > p(sid,std::vector<void*>());
00348     //    p.first=sid; //p.second is a vector, only needs to be constructed
00349     filteredevents[egid][etid]->insert(p);
00350     elv=&(*filteredevents[egid][etid]->find(sid)).second;
00351   } else {
00352     elv=&(*it).second;
00353   }
00354   elv->push_back(el); // now that everything's set up, we can add the listener
00355 }
00356 
00357 bool EventRouter::EventMapper::removeMapping(void* el, EventBase::EventGeneratorID_t egid) {
00358   // remove listener from allevents
00359   unsigned int numlist=allevents[egid].size();
00360   allevents[egid].erase(remove(allevents[egid].begin(),allevents[egid].end(),el),allevents[egid].end());
00361   bool hadListener=allevents[egid].size()!=numlist;
00362   
00363   // now remove listener from all of the filtered events
00364   for(unsigned int et=0; et<EventBase::numETIDs; et++) {
00365     SIDtoListenerVectorMap_t* mapping=filteredevents[egid][et];
00366     if(mapping!=NULL) { // if there are subscribers to this egid/etid
00367       SIDtoListenerVectorMap_t::iterator mapit=mapping->begin();
00368       for(mapit=mapping->begin(); mapit!=mapping->end(); mapit++) {// go through each sourceID, delete EL
00369         std::vector<void*> * v=&(*mapit).second;
00370         std::vector<void*>::iterator last=remove(v->begin(),v->end(),el);
00371         if(last!=v->end()) {
00372           hadListener=true;
00373           v->erase(last,v->end());
00374         }
00375       }
00376     }
00377   }
00378   return hadListener;
00379 }
00380 
00381 bool EventRouter::EventMapper::removeMapping(void* el, EventBase::EventGeneratorID_t egid, unsigned int sid, EventBase::EventTypeID_t etid) {
00382   bool hadListener=false;
00383   SIDtoListenerVectorMap_t* mapping=filteredevents[egid][etid];
00384   if(mapping!=NULL) { // if there are subscribers to this egid/etid
00385     SIDtoListenerVectorMap_t::iterator mapit=mapping->find(sid);
00386     if(mapit!=mapping->end()) {
00387       std::vector<void*> * v=&(*mapit).second;
00388       std::vector<void*>::iterator last=remove(v->begin(),v->end(),el);
00389       if(last!=v->end()) {
00390         hadListener=true;
00391         v->erase(last,v->end());
00392       }
00393     }
00394   }
00395   return hadListener;
00396 }
00397 
00398 void EventRouter::EventMapper::clean() {
00399   for(unsigned int eg=0; eg<EventBase::numEGIDs; eg++)
00400     clean((EventBase::EventGeneratorID_t)eg);
00401 }
00402 void EventRouter::EventMapper::clean(EventBase::EventGeneratorID_t egid) {
00403   // first, remove any empty sid vectors from all the mappings
00404   for(unsigned int et=0; et<EventBase::numETIDs; et++) {
00405     SIDtoListenerVectorMap_t* mapping=filteredevents[egid][et];
00406     if(mapping!=NULL) { // if there are subscribers to this egid/etid
00407       SIDtoListenerVectorMap_t::iterator mapit=mapping->begin();
00408       bool done=false;
00409       while(!done) {
00410         done=true;
00411         for(mapit=mapping->begin(); mapit!=mapping->end(); mapit++) { // go through each sourceID vector
00412           if((*mapit).second.size()==0) {
00413             mapping->erase(mapit);
00414             done=false;
00415             break;
00416           }
00417         }
00418       }
00419     }
00420   }
00421   // now remove any empty mappings
00422   for(unsigned int et=0; et<EventBase::numETIDs; et++) {
00423     SIDtoListenerVectorMap_t* mapping=filteredevents[egid][et];
00424     if(mapping!=NULL) { // if there are subscribers to this egid/etid
00425       if(mapping->size()==0) {
00426         delete mapping;
00427         filteredevents[egid][et]=NULL;
00428       }
00429     }
00430   }
00431 }
00432 
00433 void EventRouter::EventMapper::clear() {
00434   for(unsigned int eg=0; eg<EventBase::numEGIDs; eg++) {
00435     for(unsigned int et=0; et<EventBase::numETIDs; et++) {
00436       SIDtoListenerVectorMap_t* mapping=filteredevents[eg][et];
00437       if(mapping!=NULL) { // don't beat a dead horse!
00438         mapping->erase(mapping->begin(),mapping->end());
00439         delete mapping;
00440         filteredevents[eg][et]=NULL;
00441       }
00442     }
00443   }
00444 }
00445 
00446 bool EventRouter::EventMapper::hasMapping(EventBase::EventGeneratorID_t egid) {
00447   if(allevents[egid].size()>0)
00448     return true;
00449   for(unsigned int et=0; et<EventBase::numETIDs; et++) {
00450     SIDtoListenerVectorMap_t* mapping=filteredevents[egid][et];
00451     if(mapping!=NULL) {
00452       SIDtoListenerVectorMap_t::iterator mapit=mapping->begin();
00453       for(mapit=mapping->begin(); mapit!=mapping->end(); mapit++)
00454         if((*mapit).second.size()>0)
00455           return true;
00456     }
00457   }
00458   return false;
00459 }
00460 
00461 bool EventRouter::EventMapper::hasMapping(EventBase::EventGeneratorID_t egid, unsigned int sid) {
00462   if(allevents[egid].size()>0)
00463     return true;
00464   for(unsigned int et=0; et<EventBase::numETIDs; et++) {
00465     SIDtoListenerVectorMap_t* mapping=filteredevents[egid][et];
00466     if(mapping!=NULL) {
00467       SIDtoListenerVectorMap_t::iterator mapit=mapping->find(sid);
00468       if(mapit!=mapping->end() && (*mapit).second.size()>0)
00469         return true;
00470     }
00471   }
00472   return false;
00473 }
00474 
00475 bool EventRouter::EventMapper::hasMapping(EventBase::EventGeneratorID_t egid, unsigned int sid, EventBase::EventTypeID_t etid) {
00476   if(allevents[egid].size()>0)
00477     return true;
00478   SIDtoListenerVectorMap_t* mapping=filteredevents[egid][etid];
00479   if(mapping!=NULL) {
00480     SIDtoListenerVectorMap_t::iterator mapit=mapping->find(sid);
00481     if(mapit!=mapping->end())
00482       return ((*mapit).second.size()>0);
00483   }
00484   return false;
00485 }
00486 
00487 template<class T>
00488 void EventRouter::EventMapper::getMapping(const EventBase& e, std::vector<T*>& ls) {
00489   // first get all the filtered subscribers (tricky!)
00490   std::vector<void*>* elv=NULL;
00491   SIDtoListenerVectorMap_t* sidtovm=filteredevents[e.getGeneratorID()][e.getTypeID()];
00492   if(sidtovm!=NULL) { // if there's a map (at least one EL is filtering on this EGID and ETID)
00493     SIDtoListenerVectorMap_t::iterator mapit=sidtovm->find(e.getSourceID()); // find listening for this source id
00494     if(mapit!=sidtovm->end()) { // if there's at least one is filtering on this sourceID as well
00495       elv=&(*mapit).second; // now go through them all
00496       for(std::vector<void*>::iterator elit=elv->begin(); elit!=elv->end(); elit++)
00497         ls.push_back(static_cast<T*>(*elit));
00498     }
00499   }
00500   // now get the 'all events' subscribers
00501   elv=&allevents[e.getGeneratorID()];
00502   for(std::vector<void*>::iterator elit=elv->begin(); elit!=elv->end(); elit++)
00503     ls.push_back(static_cast<T*>(*elit));
00504 }
00505 
00506 bool EventRouter::EventMapper::verifyMapping(void * listener, EventBase::EventGeneratorID_t egid, unsigned int sid, EventBase::EventTypeID_t etid) {
00507   // first get all the filtered subscribers (tricky!)
00508   std::vector<void*>* elv=NULL;
00509   SIDtoListenerVectorMap_t* sidtovm=filteredevents[egid][etid];
00510   if(sidtovm!=NULL) { // if there's a map (at least one EL is filtering on this EGID and ETID)
00511     SIDtoListenerVectorMap_t::iterator mapit=sidtovm->find(sid); // find listening for this source id
00512     if(mapit!=sidtovm->end()) { // if there's at least one is filtering on this sourceID as well
00513       elv=&(*mapit).second; // now go through them all
00514       for(std::vector<void*>::iterator elit=elv->begin(); elit!=elv->end(); elit++)
00515         if(*elit==listener)
00516           return true;
00517     }
00518   }
00519   // now get the 'all events' subscribers
00520   elv=&allevents[egid];
00521   for(std::vector<void*>::iterator elit=elv->begin(); elit!=elv->end(); elit++)
00522     if(*elit==listener)
00523       return true;
00524 
00525   // if we haven't found it, doesn't exist:
00526   return false;
00527 }
00528 
00529 
00530 /*! @file
00531  * @brief Implements EventRouter class, for distribution and trapping of events to listeners
00532  * @author ejt (Creator)
00533  *
00534  * $Author: ejt $
00535  * $Name: tekkotsu-2_2 $
00536  * $Revision: 1.13 $
00537  * $State: Exp $
00538  * $Date: 2004/10/07 22:14:17 $
00539  */
00540 
00541 
00542 
00543 
00544 
00545 
00546 
00547 // Use hasListeners(*) it's faster, i doubt anyone would really care how many... (but just in case...)
00548 /*
00549 unsigned int EventRouter::numListeners(EventBase::EventGeneratorID_t egid) {
00550   unsigned int ans=allevents[egid].size();
00551   for(unsigned int et=0; et<EventBase::numETIDs; et++) {
00552     SIDtoListenerVectorMap_t* mapping=filteredevents[egid][et];
00553     if(mapping!=NULL) {
00554       SIDtoListenerVectorMap_t::iterator mapit=mapping->begin();
00555       for(mapit=mapping->begin(); mapit!=mapping->end(); mapit++)
00556         ans+=(*mapit).second.size();
00557     }
00558   }
00559   return ans;
00560 }
00561 
00562 bool EventRouter::numListeners(EventBase::EventGeneratorID_t egid, unsigned int sid) {
00563   unsigned int ans=allevents[egid].size();
00564   for(unsigned int et=0; et<EventBase::numETIDs; et++) {
00565     SIDtoListenerVectorMap_t* mapping=filteredevents[egid][et];
00566     if(mapping!=NULL) {
00567       SIDtoListenerVectorMap_t::iterator mapit=mapping->find(sid);
00568       if(mapit!=mapping->end())
00569         ans+=(*mapit).second.size();
00570     }
00571   }
00572   return false;
00573 }
00574 
00575 unsigned int EventRouter::numListeners(EventBase::EventGeneratorID_t egid, unsigned int sid, EventBase::EventTypeID_t etid) {
00576   unsigned int ans=allevents[egid].size();
00577   SIDtoListenerVectorMap_t* mapping=filteredevents[egid][etid];
00578   if(mapping!=NULL) {
00579     SIDtoListenerVectorMap_t::iterator mapit=mapping->find(sid);
00580     if(mapit!=mapping->end())
00581       ans+=(*mapit).second.size();
00582   }
00583   return ans;
00584 }
00585 */

Tekkotsu v2.2
Generated Tue Oct 19 14:19:14 2004 by Doxygen 1.3.9.1