Gaudi Framework, version v20r2
	Generated: 18 Jul 2008

IncidentSvc Class Reference

#include <IncidentSvc.h>

Inheritance diagram for IncidentSvc:

[legend]Collaboration diagram for IncidentSvc:

[legend]List of all members.

---

Detailed Description

Definition at line 23 of file IncidentSvc.h.

Public Types
typedef std::list< Listener >	ListenerList
typedef std::map< std::string, ListenerList * >	ListenerMap
Public Member Functions
virtual StatusCode	initialize ()
	Initialization (from CONFIGURED to INITIALIZED).
virtual StatusCode	finalize ()
	Finalize (from INITIALIZED to CONFIGURED).
virtual StatusCode	queryInterface (const InterfaceID &riid, void **ppvInterface)
	Query interfaces of Interface.
virtual void	addListener (IIncidentListener *lis, const std::string &type="", long priority=0, bool rethrow=false, bool singleShot=false)
	Add listener.
virtual void	removeListener (IIncidentListener *lis, const std::string &type="")
	Remove listener.
virtual void	fireIncident (const Incident &incident)
	Fire an Incident.
	IncidentSvc (const std::string &name, ISvcLocator *svc)
virtual	~IncidentSvc ()
Private Attributes
ListenerMap	m_listenerMap
const std::string *	m_currentIncidentType
	Incident being fired.
Classes
struct	Listener

---

Member Typedef Documentation

typedef std::list<Listener> IncidentSvc::ListenerList

Definition at line 40 of file IncidentSvc.h.

typedef std::map<std::string, ListenerList*> IncidentSvc::ListenerMap

Definition at line 41 of file IncidentSvc.h.

---

Constructor & Destructor Documentation

IncidentSvc::IncidentSvc	(	const std::string &	name,
		ISvcLocator *	svc
	)

Definition at line 29 of file IncidentSvc.cpp.

: Service(name, svc),m_currentIncidentType(0) {
}

IncidentSvc::~IncidentSvc

(

)

[virtual]

Definition at line 33 of file IncidentSvc.cpp.

References m_listenerMap.

                          { 
  for (ListenerMap::iterator i = m_listenerMap.begin();
       i != m_listenerMap.end();
       ++i) {
    delete i->second;
  }
}

---

Member Function Documentation

StatusCode IncidentSvc::initialize

(

)

[virtual]

Initialization (from CONFIGURED to INITIALIZED).

Reimplemented from Service.

Definition at line 45 of file IncidentSvc.cpp.

References endreq(), MSG::ERROR, Service::initialize(), StatusCode::isFailure(), Service::msgSvc(), Service::name(), Service::setProperties(), and StatusCode::SUCCESS.

                                   {
  // initialize the Service Base class
  StatusCode sc = Service::initialize();
  if ( sc.isFailure() ) {
    return sc;
  }

  MsgStream log( msgSvc(), name() ); 

  // set my own (IncidentSvc) properties via the jobOptionService 
  sc = setProperties();
  if ( sc.isFailure() ) {
    log << MSG::ERROR << "Could not set my properties" << endreq;
    return sc;
  }

  return StatusCode::SUCCESS;
}

StatusCode IncidentSvc::finalize

(

)

[virtual]

Finalize (from INITIALIZED to CONFIGURED).

Reimplemented from Service.

Definition at line 64 of file IncidentSvc.cpp.

References Service::finalize(), StatusCode::isFailure(), and StatusCode::SUCCESS.

                                 {
  // Finalize this specific service
  StatusCode sc = Service::finalize();
  if ( sc.isFailure() ) {
    return sc;
  }

  return StatusCode::SUCCESS;
}

StatusCode IncidentSvc::queryInterface	(	const InterfaceID &	riid,
		void **	ppvInterface
	)			[virtual]

Query interfaces of Interface.

Parameters:

	riid	ID of Interface to be retrieved
	ppvUnknown	Pointer to Location for interface pointer

Reimplemented from Service.

Definition at line 74 of file IncidentSvc.cpp.

References Service::addRef(), IID_IIncidentSvc, Service::queryInterface(), and StatusCode::SUCCESS.

                                                                                     {
  if ( IID_IIncidentSvc == riid )    {
    *ppvInterface = (IIncidentSvc*)this;
  }
  else  {
    // Interface is not directly available: try out a base class
    return Service::queryInterface(riid, ppvInterface);
  }
  addRef();
  return StatusCode::SUCCESS;
}

void IncidentSvc::addListener	(	IIncidentListener *	lis,
		const std::string &	type = "",
		long	priority = 0,
		bool	rethrow = false,
		bool	singleShot = false
	)			[virtual]

Add listener.

Parameters:

	lis	Listener address
	type	Incident type
	priority	Priority in handling incident

Implements IIncidentSvc.

Definition at line 90 of file IncidentSvc.cpp.

References std::list< _Tp, _Alloc >::begin(), MSG::DEBUG, std::list< _Tp, _Alloc >::end(), endreq(), std::pair< _T1, _T2 >::first, getListenerName(), std::list< _Tp, _Alloc >::insert(), m_listenerMap, Service::msgSvc(), Service::name(), std::pair< _T1, _T2 >::second, and Service::type().

                                                                                          {

  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;
    }
  }

  MsgStream log ( msgSvc() , name());
  log << MSG::DEBUG << "Adding [" << type << "] listener '" << getListenerName(lis)
      << "' with priority " << prio << endreq;
  
  llist->insert(itlist, Listener(lis, prio, rethrow, singleShot));
  return;
}

void IncidentSvc::removeListener	(	IIncidentListener *	lis,
		const std::string &	type = ""
	)			[virtual]

Remove listener.

Parameters:

	lis	Listener address
	type	Incident type

Implements IIncidentSvc.

Definition at line 123 of file IncidentSvc.cpp.

References std::list< _Tp, _Alloc >::begin(), MSG::DEBUG, std::list< _Tp, _Alloc >::end(), endreq(), std::list< _Tp, _Alloc >::erase(), getListenerName(), m_currentIncidentType, m_listenerMap, Service::msgSvc(), Service::name(), std::list< _Tp, _Alloc >::size(), and Service::type().

                                                                              {

  MsgStream log ( msgSvc() , name());
  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 recursivelly 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 {
            log << MSG::DEBUG << "Removing [" << type << "] listener '"
                << getListenerName(lis) << "'" << endreq;
            itlist = llist->erase(itlist); // remove from the list now
          }
        }
        else {
          itlist++;
        }
      }
      if( llist->size() == 0) {
        delete llist;
        m_listenerMap.erase(itmap);
      }
    }
  }
  return;
}

void IncidentSvc::fireIncident

(

const Incident &

incident

)

[virtual]

Fire an Incident.

Parameters:

Incident

being fired

Implements IIncidentSvc.

Definition at line 184 of file IncidentSvc.cpp.

References endreq(), MSG::ERROR, getListenerName(), m_currentIncidentType, m_listenerMap, Service::msgSvc(), Service::name(), GaudiException::tag(), Incident::type(), MSG::VERBOSE, and std::exception::what().

                                                         {
        // setting this pointer will avoid that a call to removeListener() during
        // the loop triggers a segfault
  m_currentIncidentType = &(incident.type());
  
  MsgStream log ( msgSvc() , name());
  ListenerMap::iterator itmap = m_listenerMap.find( incident.type() );
  if( itmap != m_listenerMap.end() ) {
    ListenerList* llist = (*itmap).second;
    ListenerList::iterator itlist;
    bool weHaveToCleanUp = false;
    // loop over all registered Listeners
    for( itlist = llist->begin(); itlist != llist->end(); itlist++ ) {
      log << MSG::VERBOSE << "Calling '" << getListenerName((*itlist).iListener)
          << "' for incident [" << incident.type() << "]" << endreq;

      // handle exceptions if they occur
      try {
        (*itlist).iListener->handle(incident);
      }
      catch( const GaudiException& exc ) {
       log << MSG::ERROR << "Exception with tag=" << exc.tag() << " is caught " << endreq;
       log << MSG::ERROR <<  exc  << endreq;
       if ( (*itlist).rethrow ) { throw (exc); }
      }
      catch( const std::exception& exc ) {
       log << MSG::ERROR << "Standard std::exception is caught " << endreq;
       log << MSG::ERROR << exc.what()  << endreq;
       if ( (*itlist).rethrow ) { throw (exc); }
      }
      catch(...) {
       log << MSG::ERROR << "UNKNOWN Exception is caught " << endreq;
       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 = NULL;
  return;
}

---

Member Data Documentation

ListenerMap IncidentSvc::m_listenerMap [private]

Definition at line 63 of file IncidentSvc.h.

Referenced by addListener(), fireIncident(), removeListener(), and ~IncidentSvc().

const std::string* IncidentSvc::m_currentIncidentType [private]

Incident being fired.

It is used to know if we can safely remove a listener or we have to schedule its removal for later.

Definition at line 66 of file IncidentSvc.h.

Referenced by fireIncident(), and removeListener().

---

The documentation for this class was generated from the following files:

• /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v20r2/GaudiSvc/v17r1/src/IncidentSvc/IncidentSvc.h
• /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v20r2/GaudiSvc/v17r1/src/IncidentSvc/IncidentSvc.cpp

---