---

IncidentSvc.cpp

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/GaudiSvc/src/IncidentSvc/IncidentSvc.cpp,v 1.1.1.2 2001/04/18 18:32:50 tlindner Exp $

// Include Files
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/IIncidentListener.h"
#include "GaudiKernel/Incident.h"
#include "GaudiKernel/GaudiException.h"
#include "IncidentSvc.h"

// Instantiation of a static factory class used by clients to create
//  instances of this service
static SvcFactory<IncidentSvc> s_factory;
const ISvcFactory& IncidentSvcFactory = s_factory;

//============================================================================================
// Constructors and Desctructors
//============================================================================================
IncidentSvc::IncidentSvc( const std::string& name, ISvcLocator* svc )
: Service(name, svc) {
}

IncidentSvc::~IncidentSvc() { 
}

//============================================================================================
// Inherited Service overrides:
//============================================================================================
//
StatusCode IncidentSvc::initialize() {
  // 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 
  setProperties();

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

  return StatusCode::SUCCESS;
}
  
StatusCode IncidentSvc::queryInterface( const IID& riid, void** ppvInterface ) {
  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;
}
  
//============================================================================================
// Inherited IIncidentSvc overrides:
//============================================================================================
//
void IncidentSvc::addListener(IIncidentListener* lis, const std::string& type, long prio) {
  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).second < prio ) {
      // We insert before the current position
      break;
    }
  }
  llist->insert(itlist, Listener(lis, prio));
  return;
}
void IncidentSvc::removeListener(IIncidentListener* lis, const std::string& type) {
  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;
      // 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).first == lis || lis == 0) {
          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 ) {
  MsgStream log ( msgSvc() , name());
  ListenerMap::iterator itmap = m_listenerMap.find( incident.type() );
  if( itmap != m_listenerMap.end() ) {
    ListenerList* llist = (*itmap).second;
    ListenerList::iterator itlist;
    // loop over all registered Listeners
    for( itlist = llist->begin(); itlist != llist->end(); itlist++ ) {
      // handle exceptions if they occur
      try {
        (*itlist).first->handle(incident);
      }
      catch( const GaudiException& exc ) {
       log << MSG::ERROR << "Exception with tag=" << exc.tag() << " is caught " << endreq;
       log << MSG::ERROR <<  exc  << endreq;
      }
      catch( const std::exception& exc ) {
       log << MSG::ERROR << "Standard std::exception is caught " << endreq;
       log << MSG::ERROR << exc.what()  << endreq;
      }
      catch(...) {
       log << MSG::ERROR << "UNKNOWN Exception is caught " << endreq;
      }
    }
  } 
  return;
}

---