// ============================================================================ // Inherited IIncidentSvc overrides: // ============================================================================ void IncidentSvc::addListener ( IIncidentListener* lis , const std::string& type , long prio, bool rethrow, bool singleShot) { boost::recursive_mutex::scoped_lock lock(m_listenerMapMutex); std::string ltype; if( type == "" ) ltype = "ALL"; else ltype = type; // find if the type already exists ListenerMap::iterator itMap = m_listenerMap.find( ltype ); if( itMap == m_listenerMap.end() ) { // if not found, create and insert now a list of listeners ListenerList* newlist = new ListenerList(); std::pair<ListenerMap::iterator, bool> p; p = m_listenerMap.insert(ListenerMap::value_type(ltype, newlist)); if( p.second ) itMap = p.first; } ListenerList* llist = (*itMap).second; // add Listener in the ListenerList according to the priority ListenerList::iterator itlist; for( itlist = llist->begin(); itlist != llist->end(); itlist++ ) { if( (*itlist).priority < prio ) { // We insert before the current position break; } } DEBMSG << "Adding [" << type << "] listener '" << getListenerName(lis) << "' with priority " << prio << endmsg; llist->insert(itlist, Listener(lis, prio, rethrow, singleShot)); }
// // Manager::getListenerList - Chapter 10, page 300 // // Get the list of listeners associated with a specific event // type // ListenerList Manager::GetListenerList( TypeId const & eventType ) const { // invalid event type, so sad if ( ! VValidateType( eventType ) ) return ListenerList(); EventListenerMap::const_iterator itListeners = m_registry.find( eventType.Value() ); // no listerners currently for this event type, so sad if ( itListeners == m_registry.end() ) return ListenerList(); EventListenerTable const & table = itListeners->second; // there was, but is not now, any listerners currently for // this event type, so sad if ( table.size() == 0 ) return ListenerList(); ListenerList result; result.reserve( table.size() ); for ( EventListenerTable::const_iterator it = table.begin(), end = table.end(); it != end; it++ ) { result.push_back( *it ); } return result; }
void EventManager::broadcastEvent(const Event &event) { do { if (mListenerMap.empty()) break; EventID eid = event.getEventID(); ListenerList *listenerList = NULL; ListenerMap::iterator mapIter = mListenerMap.find(eid); if (mapIter == mListenerMap.end()) break; listenerList = mapIter->second; if (listenerList->empty()) break; ListenerList::iterator listIter; for (listIter = listenerList->begin(); listIter != listenerList->end(); ++listIter) { (*listIter)->handleEvent(event); } } while (0); }
//----------------------------------------------------------------------- void Camera::_renderScene(Viewport *vp, bool includeOverlays) { OgreProfileBeginGPUEvent("Camera: " + getName()); //update the pixel display ratio if (mProjType == Ogre::PT_PERSPECTIVE) { mPixelDisplayRatio = (2 * Ogre::Math::Tan(mFOVy * 0.5f)) / vp->getActualHeight(); } else { mPixelDisplayRatio = (mTop - mBottom) / vp->getActualHeight(); } //notify prerender scene ListenerList listenersCopy = mListeners; for (ListenerList::iterator i = listenersCopy.begin(); i != listenersCopy.end(); ++i) { (*i)->cameraPreRenderScene(this); } //render scene mSceneMgr->_renderScene(this, vp, includeOverlays); // Listener list may have change listenersCopy = mListeners; //notify postrender scene for (ListenerList::iterator i = listenersCopy.begin(); i != listenersCopy.end(); ++i) { (*i)->cameraPostRenderScene(this); } OgreProfileEndGPUEvent("Camera: " + getName()); }
void EventManager::removeListener(GameObject *listener) { do { if (mListenerMap.empty()) break; ListenerMap::iterator mapIter = mListenerMap.begin(); for (; mapIter != mListenerMap.end(); ++mapIter) { ListenerList *list = mapIter->second; if (list == NULL) continue; ListenerList::iterator listIter = list->begin(); for (; listIter != list->end(); ++listIter) { if (*listIter == listener) { list->erase(listIter); break; } } } } while (0); }
void WeakRef::_notifyDestroy() { incRefCount(); ListenerList* listeners = _listeners; _listeners = NULL; // prevent removeListener mutate this if (listeners) { for (ListenerList::iterator itr = listeners->begin(), end = listeners->end(); itr != end; ++itr) { (*itr)->onDestroy(_object); } delete listeners; } _object = NULL; if (_listeners) { decRefCount(); NIT_THROW_FMT(EX_INVALID_STATE, "Can't add listener while destroying one"); return; } decRefCount(); }
//----------------------------------------------------------------------- Camera::~Camera() { ListenerList listenersCopy = mListeners; for (ListenerList::iterator i = listenersCopy.begin(); i != listenersCopy.end(); ++i) { (*i)->cameraDestroyed(this); } }
void Environment::cleanupUnusedListeners(ListenerList& list) { for(ListenerList::iterator giter = list.begin(); giter != list.end();){ if((*giter)->isActive() == false){ giter = list.erase(giter); } else ++giter; } }
// ============================================================================ void IncidentSvc::removeListener ( IIncidentListener* lis , const std::string& type ) { boost::recursive_mutex::scoped_lock lock(m_listenerMapMutex); if( type == "") { // remove Listener from all the lists ListenerMap::iterator itmap; for ( itmap = m_listenerMap.begin(); itmap != m_listenerMap.end();) { // since the current entry may be eventually deleted // we need to keep a memory of the next index before // calling recursively this method ListenerMap::iterator itmap_old = itmap; itmap++; removeListener( lis, (*itmap_old).first ); } } else { ListenerMap::iterator itmap = m_listenerMap.find( type ); if( itmap == m_listenerMap.end() ) { // if not found the incident type then return return; } else { ListenerList* llist = (*itmap).second; ListenerList::iterator itlist; bool justScheduleForRemoval = ( 0!= m_currentIncidentType ) && (type == *m_currentIncidentType); // loop over all the entries in the Listener list // to remove all of them than matches // the listener address. Remember the next index // before erasing the current one for( itlist = llist->begin(); itlist != llist->end(); ) { if( (*itlist).iListener == lis || lis == 0) { if (justScheduleForRemoval) { (itlist++)->singleShot = true; // remove it as soon as it is safe } else { DEBMSG << "Removing [" << type << "] listener '" << getListenerName(lis) << "'" << endmsg; itlist = llist->erase(itlist); // remove from the list now } } else { itlist++; } } if( llist->size() == 0) { delete llist; m_listenerMap.erase(itmap); } } } }
bool Environment::stopListener(ListenerList& list, uint32_t id) { for(ListenerList::iterator giter = list.begin(), gend = list.end(); giter != gend; ++giter) { if((*giter)->getID() == id && (*giter)->isActive()){ (*giter)->deactivate(); return true; } } return false; }
void EventManager::removeListenerByEventID(EventID eventID) { if (mListenerMap.empty()) return; ListenerMap::iterator mapIter = mListenerMap.find(eventID); if (mapIter == mListenerMap.end()) return; ListenerList *list = mapIter->second; if (list == NULL) return; list->clear(); }
//--------------------------------------------------------------------- Viewport::~Viewport() { ListenerList listenersCopy; std::swap(mListeners, listenersCopy); for (ListenerList::iterator i = listenersCopy.begin(); i != listenersCopy.end(); ++i) { (*i)->viewportDestroyed(this); } RenderSystem* rs = Root::getSingleton().getRenderSystem(); if ((rs) && (rs->_getViewport() == this)) { rs->_setViewport(NULL); } }
void EventManager::addListener(GameObject *listener, EventID eventID) { ListenerMap::iterator mapIter = mListenerMap.find(eventID); // listener list for eventID is empty, need create first if (mapIter == mListenerMap.end()) { ListenerList *newList = new ListenerList; mListenerMap.insert(ListenerMap::value_type(eventID, newList)); newList->push_back(listener); } else { (mapIter->second)->push_back(listener); } }
void MamdaMultiSecurityManager::MamdaMultiSecurityManagerImpl::forwardMsg ( ListenerList& listeners, MamdaSubscription* subscription, const MamaMsg& msg, short msgType) { ListenerList::iterator end = listeners.end(); ListenerList::iterator i = listeners.begin(); for (; i != end; ++i) { MamdaMsgListener* listener = *i; listener->onMsg (subscription, msg, msgType); } }
void EventManager::removeAllListeners() { do { if (mListenerMap.empty()) break; ListenerMap::iterator mapIter = mListenerMap.begin(); for (; mapIter != mListenerMap.end(); ++mapIter) { ListenerList *list = mapIter->second; if (list == NULL) continue; list->clear(); } } while (0); }
void Camera::_renderScene(Viewport *vp, BOOL includeOverlays) { if (mProjType == PT_PERSPECTIVE) { mPixelDisplayRatio = (2 * Math::Tan((Radian)(mFOVy * 0.5f))) / vp->getActualHeight(); } else { mPixelDisplayRatio = (mTop - mBottom) / vp->getActualHeight(); } ListenerList listenersCopy = mListeners; for (ListenerList::iterator i = listenersCopy.begin(); i != listenersCopy.end(); ++i) { (*i)->cameraPreRenderScene(this); } mSceneMgr->renderScene(this, vp, includeOverlays); listenersCopy = mListeners; for (ListenerList::iterator i = listenersCopy.begin(); i != listenersCopy.end(); ++i) { (*i)->cameraPostRenderScene(this); } }
// ============================================================================ void IncidentSvc::i_fireIncident ( const Incident& incident , const std::string& listenerType ) { boost::recursive_mutex::scoped_lock lock(m_listenerMapMutex); // Special case: FailInputFile incident must set the application return code if (incident.type() == IncidentType::FailInputFile || incident.type() == IncidentType::CorruptedInputFile) { SmartIF<IProperty> appmgr(serviceLocator()); if (incident.type() == IncidentType::FailInputFile) // Set the return code to Gaudi::ReturnCode::FailInput (2) Gaudi::setAppReturnCode(appmgr, Gaudi::ReturnCode::FailInput).ignore(); else Gaudi::setAppReturnCode(appmgr, Gaudi::ReturnCode::CorruptedInput).ignore(); } ListenerMap::iterator itmap = m_listenerMap.find( listenerType ); if ( m_listenerMap.end() == itmap ) return; // setting this pointer will avoid that a call to removeListener() during // the loop triggers a segfault m_currentIncidentType = &(incident.type()); ListenerList* llist = (*itmap).second; ListenerList::iterator itlist; bool weHaveToCleanUp = false; // loop over all registered Listeners for( itlist = llist->begin(); itlist != llist->end(); itlist++ ) { VERMSG << "Calling '" << getListenerName((*itlist).iListener) << "' for incident [" << incident.type() << "]" << endmsg; // handle exceptions if they occur try { (*itlist).iListener->handle(incident); } catch( const GaudiException& exc ) { error() << "Exception with tag=" << exc.tag() << " is caught" " handling incident" << m_currentIncidentType << endmsg; error() << exc << endmsg; if ( (*itlist).rethrow ) { throw (exc); } } catch( const std::exception& exc ) { error() << "Standard std::exception is caught" " handling incident" << m_currentIncidentType << endmsg; error() << exc.what() << endmsg; if ( (*itlist).rethrow ) { throw (exc); } } catch(...) { error() << "UNKNOWN Exception is caught" " handling incident" << m_currentIncidentType << endmsg; if ( (*itlist).rethrow ) { throw; } } // check if at least one of the listeners is a one-shot weHaveToCleanUp |= itlist->singleShot; } if (weHaveToCleanUp) { // remove all the listeners that need to be removed from the list llist->remove_if( listenerToBeRemoved() ); // if the list is empty, we can remove it if( llist->size() == 0) { delete llist; m_listenerMap.erase(itmap); } } m_currentIncidentType = 0; }
void EventManager<T>::temporary_processEventQueue(AbsTime forceCompletionBy) { AbsTime startTime = AbsTime::now(); SILOG(task,insane," >>> Processing events."); // swaps to allow people to keep adding new events typename EventList::NodeIterator processingList(mUnprocessed); // The events are swapped first to guarantee that listeners are at least as up-to-date as events. // Events can be delayed, but we cannot allow any lost subscriptions/unsubscriptions. { typename ListenerRequestList::NodeIterator procListeners(mListenerRequests); const ListenerRequest *req; while ((req = procListeners.next()) != NULL) { if (req->subscription) { SILOG(task,debug," >>>\tDoing subscription listener "<< req->listenerId << " for event " << req->eventId << " (" << req->onlyPrimary << ")."); doSubscribeId(*req); } else { SILOGNOCR(task,debug," >>>\t"); if (req->notifyListener) { SILOGNOCR(task,debug,"Notifying"); } SILOG(task,debug,"UNSUBSCRIBED listener " << req->listenerId << "."); doUnsubscribe(req->listenerId, req->notifyListener); } } } if (SILOGP(task,insane)){ SILOG(task,insane,"==== All Event Subscribers for " << (intptr_t)this << " ===="); typename PrimaryListenerMap::const_iterator priIter = mListeners.begin(); while (priIter != mListeners.end()) { SILOG(task,insane," ID " << (*priIter).first << ":"); PartiallyOrderedListenerList *primaryLists = &((*priIter).second->first); SecondaryListenerMap *secondaryMap = &((*priIter).second->second); for (int i = 0; i < NUM_EVENTORDER; i++) { ListenerList *currentList = &(primaryLists->get(i)); for (typename ListenerList::const_iterator iter = currentList->begin(); iter != currentList->end(); ++iter) { SILOG(task,insane," \t" "[" << (i==MIDDLE?'=':i<MIDDLE?'*':'/') << "] " << (*iter).second); } } typename SecondaryListenerMap::const_iterator secIter; secIter = secondaryMap->begin(); while (secIter != secondaryMap->end()) { SILOG(task,insane,"\tSec ID " << (*secIter).first << ":"); for (int i = 0; i < NUM_EVENTORDER; i++) { ListenerList *currentList = &((*secIter).second->get(i)); for (typename ListenerList::const_iterator iter = currentList->begin(); iter != currentList->end(); ++iter) { SILOG(task,insane," \t\t" "[" << (i==MIDDLE?'=':i<MIDDLE?'*':'/') << "] " << (*iter).second); } } ++secIter; } ++priIter; } SILOG(task,insane,"==== ---------------------------------- ===="); } EventPtr *evTemp; int numProcessed = 0; while ((evTemp = processingList.next())!=NULL) { EventPtr ev (*evTemp); ++numProcessed; typename PrimaryListenerMap::iterator priIter = mListeners.find(ev->getId().mPriId); if (priIter == mListeners.end()) { // FIXME: Should this ever happen? SILOG(task,warning," >>>\tWARNING: No listeners for type " << "event type " << ev->getId().mPriId); continue; } PartiallyOrderedListenerList *primaryLists = &((*priIter).second->first); SecondaryListenerMap *secondaryMap = &((*priIter).second->second); typename SecondaryListenerMap::iterator secIter; secIter = secondaryMap->find(ev->getId().mSecId); bool cancel = false; EventHistory eventHistory=EVENT_UNHANDLED; // Call once per event order. for (int i = 0; i < NUM_EVENTORDER && cancel == false; i++) { SILOG(task,debug," >>>\tFiring " << ev << ": " << ev->getId() << " [order " << i << "]"); ListenerList *currentList = &(primaryLists->get(i)); if (!currentList->empty()) eventHistory=EVENT_HANDLED; if (callAllListeners(ev, currentList, forceCompletionBy)) { cancel = cancel || true; } if (secIter != secondaryMap->end() && !(*secIter).second->get(i).empty()) { currentList = &((*secIter).second->get(i)); if (!currentList->empty()) eventHistory=EVENT_HANDLED; if (callAllListeners(ev, currentList, forceCompletionBy)) { cancel = cancel || true; } // all listeners may have returned false. // cleanUp(secondaryMap, secIter); // secIter = secondaryMap->find(ev->getId().mSecId); } if (cancel) { SILOG(task,debug," >>>\tCancelling " << ev->getId()); } } if (secIter != secondaryMap->end()) { cleanUp(secondaryMap, secIter); } if (cancel) eventHistory=EVENT_CANCELED; (*ev)(eventHistory); SILOG(task,debug," >>>\tFinished " << ev->getId()); } if (mEventCV) { mPendingEvents -= numProcessed; } AbsTime finishTime = AbsTime::now(); SILOG(task,insane, "**** Done processing events this round. " << "Took " << (finishTime-startTime).toSeconds() << " seconds."); }