HistorySvc Class Reference

#include <HistorySvc.h>

Inheritance diagram for HistorySvc:

[legend]

Collaboration diagram for HistorySvc:

[legend]

List of all members.

---

Detailed Description

Definition at line 45 of file HistorySvc.h.

Public Member Functions
virtual StatusCode	initialize ()
	Initialization (from CONFIGURED to INITIALIZED).
virtual StatusCode	reinitialize ()
	Initialization (from INITIALIZED or RUNNING to INITIALIZED, via CONFIGURED).
virtual StatusCode	finalize ()
	Finalize (from INITIALIZED to CONFIGURED).
virtual StatusCode	captureState ()
virtual StatusCode	queryInterface (const InterfaceID &riid, void **ppvInterface)
	Query interfaces of Interface.
virtual StatusCode	registerJob ()
virtual StatusCode	listProperties () const
virtual JobHistory *	getJobHistory () const
virtual StatusCode	registerSvc (const IService &)
virtual StatusCode	listProperties (const IService &) const
virtual ServiceHistory *	getServiceHistory (const IService &) const
virtual void	getServiceHistory (std::set< ServiceHistory * > &) const
virtual StatusCode	registerAlg (const Algorithm &)
virtual StatusCode	listProperties (const Algorithm &) const
virtual AlgorithmHistory *	getAlgHistory (const Algorithm &) const
virtual void	getAlgHistory (std::set< AlgorithmHistory * > &) const
virtual StatusCode	registerAlgTool (const IAlgTool &)
virtual StatusCode	listProperties (const IAlgTool &) const
virtual AlgToolHistory *	getAlgToolHistory (const IAlgTool &) const
virtual void	getAlgToolHistory (std::set< AlgToolHistory * > &) const
virtual DataHistory *	createDataHistoryObj (const CLID &id, const std::string &key, const std::string &store)
virtual StatusCode	registerDataHistory (const CLID &id, const std::string &key, const std::string &store)
virtual DataHistory *	getDataHistory (const CLID &id, const std::string &key, const std::string &store) const
virtual int	getDataHistory (const CLID &id, const std::string &key, const std::string &storeName, std::list< DataHistory * > &dhlist) const
	HistorySvc (const std::string &name, ISvcLocator *svc)
virtual void	handle (const Incident &inc)
	Inform that a new incident has occured.
virtual	~HistorySvc ()
Private Types
typedef std::multimap< DHH, DataHistory * >	DataHistMap
typedef DataHistMap::iterator	DHMitr
typedef DataHistMap::const_iterator	DHMCitr
Private Member Functions
void	clearState ()
void	dumpProperties (std::ofstream &) const
void	dumpProperties (const IService &, std::ofstream &) const
void	dumpProperties (const Algorithm &, std::ofstream &) const
void	dumpProperties (const IAlgTool &, std::ofstream &) const
void	dumpState (std::ofstream &) const
void	dumpState (const IService &, std::ofstream &) const
void	dumpState (const Algorithm &, std::ofstream &) const
void	dumpState (const IAlgTool &, std::ofstream &) const
std::string	dumpProp (const Property *) const
IAlgorithm *	getCurrentIAlg () const
Private Attributes
bool	m_isInitialized
bool	m_dump
bool	m_activate
IAlgContextSvc *	p_algCtxSvc
std::set< const Algorithm * >	m_algs
std::map< const Algorithm *, AlgorithmHistory * >	m_algmap
std::set< const IAlgTool * >	m_ialgtools
std::set< const AlgTool * >	m_algtools
std::map< const AlgTool *, AlgToolHistory * >	m_algtoolmap
std::set< const IService * >	m_svcs
std::map< const IService *, ServiceHistory * >	m_svcmap
std::multimap< DHH, DataHistory * >	m_datMap
JobHistory *	m_jobHistory
std::string	m_outputFile
IIncidentSvc *	m_incidentSvc
MsgStream	m_log
Friends
class	SvcFactory< HistorySvc >

---

Member Typedef Documentation

typedef std::multimap<DHH,DataHistory*> HistorySvc::DataHistMap [private]

Definition at line 105 of file HistorySvc.h.

typedef DataHistMap::iterator HistorySvc::DHMitr [private]

Definition at line 106 of file HistorySvc.h.

typedef DataHistMap::const_iterator HistorySvc::DHMCitr [private]

Definition at line 107 of file HistorySvc.h.

---

Constructor & Destructor Documentation

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

Definition at line 69 of file HistorySvc.cpp.

  : Service( name, svc ), 
    m_isInitialized(false),
    m_dump(false),
    p_algCtxSvc(0),
    m_jobHistory(0),
    m_outputFile(""),
    m_incidentSvc(0),
    m_log(msgSvc(), name )
    
{
    declareProperty("Dump",m_dump);
    declareProperty("Activate", m_activate=true);
    declareProperty("OutputFile",m_outputFile);

    // hack to bring in environ
    vector<string> envtmp = System::getEnv();

}

HistorySvc::~HistorySvc

(

)

[virtual]

Definition at line 91 of file HistorySvc.cpp.

                        {
  delete m_jobHistory;
}

---

Member Function Documentation

StatusCode HistorySvc::initialize

(

)

[virtual]

Initialization (from CONFIGURED to INITIALIZED).

Reimplemented from Service.

Definition at line 140 of file HistorySvc.cpp.

                                  {

  StatusCode status = Service::initialize();
  m_log.setLevel( m_outputLevel.value() );

  if (status.isFailure()) {
#ifndef NDEBUG
    m_log << MSG::DEBUG << "Failed to initialize the base class (Service)" 
          << endreq;
#endif
    return status;
  }

#ifndef NDEBUG
  m_log << MSG::DEBUG << "Initializing HistorySvc" << endreq;
#endif

  if (!m_activate) return StatusCode::SUCCESS;

  static const bool CREATEIF(true);

  if ( service("AlgContextSvc",p_algCtxSvc,CREATEIF).isFailure() ) {
    m_log << MSG::ERROR << "unable to get the AlgContextSvc" << endreq;
    return StatusCode::FAILURE;
  }

  if (service("IncidentSvc", m_incidentSvc, CREATEIF).isFailure()) {
    m_log << MSG::ERROR << "unable to get the IncidentSvc" << endreq;
    return StatusCode::FAILURE;
  }

  // create a weak dependency on the ToolSvc, so that it doesn't get deleted
  // before we're done with it in finalize
  if (ServiceHandle<IToolSvc>("ToolSvc/ToolSvc",name()).retrieve().isFailure()) {
    m_log << MSG::ERROR << "could not retrieve the ToolSvc handle !"
          << endreq;
    return StatusCode::FAILURE;
  }

  // add listener to be triggered by first BeginEvent with low priority
  // so it gets called first
  const bool rethrow = false;
  const bool oneShot = true; // make the listener called only once 
  m_incidentSvc->addListener(this,IncidentType::BeginEvent,
                             std::numeric_limits<long>::min(),rethrow,oneShot);

  m_isInitialized = true;

  return StatusCode::SUCCESS;

}

StatusCode HistorySvc::reinitialize

(

)

[virtual]

Initialization (from INITIALIZED or RUNNING to INITIALIZED, via CONFIGURED).

Reimplemented from Service.

Definition at line 97 of file HistorySvc.cpp.

                                    {

  clearState();

  m_state = Gaudi::StateMachine::OFFLINE;

  return initialize();

}

StatusCode HistorySvc::finalize

(

)

[virtual]

Finalize (from INITIALIZED to CONFIGURED).

Reimplemented from Service.

Definition at line 297 of file HistorySvc.cpp.

                                {

  if (!m_activate) return StatusCode::SUCCESS;

  if (m_dump) {
    listProperties().ignore();
  }

  if (m_outputFile != "") {
    std::ofstream ofs;
    ofs.open(m_outputFile.c_str());
    if (!ofs) {
      m_log << MSG::ERROR << "Unable to open output file \"m_outputFile\""
            << endreq;
    } else {

      //      dumpProperties(ofs);
      dumpState(ofs);

      ofs.close();
    }
  }

  clearState();

  StatusCode status = Service::finalize();

  if ( status.isSuccess() )
    m_log << MSG::INFO << "Service finalised successfully" << endreq;

  return status;

}

StatusCode HistorySvc::captureState

(

)

[virtual]

Get all the Algorithms

Get all the AlgTools

Get all the Services

Definition at line 193 of file HistorySvc.cpp.

                                    {

  if (m_jobHistory == 0) {
    m_jobHistory = new JobHistory;
    IJobOptionsSvc *jo;
    if (service("JobOptionsSvc",jo).isFailure()) {
       m_log << MSG::ERROR 
             << "Could not get jobOptionsSvc - "
             << "not adding properties to JobHistory" << endreq;
    } else {

      bool foundAppMgr(false);

      std::vector<std::string> clients = jo->getClients();
      std::vector<std::string>::const_iterator it;
      std::vector<const Property*>::const_iterator itr;
      for (it=clients.begin(); it!=clients.end(); ++it) {
        if (*it == "ApplicationMgr") {
          foundAppMgr = true;
        }
        const std::vector<const Property*> *props = jo->getProperties(*it);
        for (itr=props->begin(); itr != props->end(); ++itr) {
          m_jobHistory->addProperty( *it, *itr );
        }
      }

      if (!foundAppMgr) {
        IProperty *ap;
        if (service("ApplicationMgr",ap).isFailure()) {
          m_log << MSG::ERROR << "could not get the ApplicationMgr" << endreq;
        } else {
          std::vector<Property*>::const_iterator itr2;
          const std::vector<Property*> props = ap->getProperties();
          for (itr2=props.begin(); itr2 != props.end(); ++itr2) {
            m_jobHistory->addProperty( "ApplicationMgr", *itr2 );
          }
        }
      }

    }
  }


  StatusCode sc;
  IAlgManager* algMgr = 0;
  sc = Gaudi::svcLocator()->queryInterface( IID_IAlgManager, 
                                            pp_cast<void>(&algMgr) );
  if (sc.isFailure()) {
    m_log << MSG::ERROR << "Could not get AlgManager" << endreq;
    return StatusCode::FAILURE;
  } else {

    std::list<IAlgorithm*> algs;
    algs = algMgr->getAlgorithms();
    std::list<IAlgorithm*>::const_iterator itr;
    for (itr=algs.begin(); itr!=algs.end(); ++itr) {
      Algorithm* alg = dynamic_cast<Algorithm*> (*itr);
      if (alg == 0) {
        m_log << MSG::WARNING << "Algorithm " << (*itr)->name() 
              << " does not inherit from Algorithm. Not registering it."
              << endreq;
      } else {
        registerAlg( *alg ).ignore();
      }
    }
    
    m_log << MSG::INFO;
    m_log << "Registered " << algs.size() << " Algorithms" << endreq;
    
  }


  m_isInitialized = true;
  std::set<const IAlgTool*>::const_iterator itra;
  for (itra = m_ialgtools.begin(); itra != m_ialgtools.end(); ++itra) {
    (const_cast<IAlgTool*>(*itra))->addRef();
    registerAlgTool(**itra).ignore();
  }

  m_log << MSG::INFO << "Registered " << m_algtools.size() << " AlgTools"
        << endreq;


  std::list<IService*> svcs = Gaudi::svcLocator()->getServices();
  
  std::list<IService*>::const_iterator itrs;
  for (itrs=svcs.begin(); itrs!=svcs.end(); ++itrs) {
    (*itrs)->addRef();
    registerSvc(**itrs).ignore();
  }
  
  m_log << MSG::INFO;
  m_log << "Registered " << svcs.size() << " Services" << endreq;

  return StatusCode::SUCCESS;


}

StatusCode HistorySvc::queryInterface	(	const InterfaceID &	riid,
		void **	ppvUnknown
	)			[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 333 of file HistorySvc.cpp.

{
  StatusCode sc = StatusCode::FAILURE;
  if ( ppvInterface ) {
    *ppvInterface = 0;
    
    if ( IHistorySvc::interfaceID().versionMatch(riid) )    {
      *ppvInterface = static_cast<IHistorySvc*>(this);
      sc = StatusCode::SUCCESS;
      addRef();
    }
    else
      sc = Service::queryInterface( riid, ppvInterface );    
  }
  return sc;
}

StatusCode HistorySvc::registerJob

(

)

[virtual]

Implements IHistorySvc.

Definition at line 459 of file HistorySvc.cpp.

                        {


  return StatusCode(StatusCode::SUCCESS,true);


}

StatusCode HistorySvc::listProperties

(

)

const [virtual]

Implements IHistorySvc.

Definition at line 470 of file HistorySvc.cpp.

                                 {

  m_log << MSG::INFO;
  m_log.setColor(MSG::CYAN);
  m_log << "Dumping properties for all Algorithms" << endreq;

  std::map<const Algorithm*, AlgorithmHistory*>::const_iterator itr;
  for (itr=m_algmap.begin(); itr != m_algmap.end(); ++itr) {
    const Algorithm* alg = itr->first;

    listProperties( *alg ).ignore();

  }

  m_log << MSG::INFO;
  m_log.setColor(MSG::CYAN);
  m_log << "Dumping properties for all AlgTools" << endreq;

  std::map<const AlgTool*, AlgToolHistory*>::const_iterator itr_a;
  for (itr_a=m_algtoolmap.begin(); itr_a != m_algtoolmap.end(); ++itr_a) {
    const AlgTool* alg = itr_a->first;

    listProperties( *alg ).ignore();

  }

  m_log << MSG::INFO;
  m_log.setColor(MSG::CYAN);
  m_log << "Dumping properties for all Services" << endreq;

  std::map<const IService*, ServiceHistory*>::const_iterator itr_s;
  for (itr_s=m_svcmap.begin(); itr_s != m_svcmap.end(); ++itr_s) {
    const IService* svc = itr_s->first;

    listProperties( *svc ).ignore();

  }

  m_log << MSG::INFO;
  m_log.setColor(MSG::CYAN);
  m_log << "Dumping properties for Job";
  m_log.resetColor();
  
  ostringstream ost;
  ost << *m_jobHistory;
  std::string str = ost.str();

  m_log << std::endl << str << endreq;
  
  return StatusCode(StatusCode::SUCCESS,true);

}

JobHistory * HistorySvc::getJobHistory

(

)

const [virtual]

Implements IHistorySvc.

Definition at line 569 of file HistorySvc.cpp.

                                {

  return m_jobHistory;

}

StatusCode HistorySvc::registerSvc

(

const IService &

svc

)

[virtual]

Implements IHistorySvc.

Definition at line 715 of file HistorySvc.cpp.

                                           {

  if ( svc.name() == "HistoryStore" ) {
    //    m_log << MSG::WARNING << "not registering store" << endreq;
    return StatusCode(StatusCode::SUCCESS,true);
  }

  JobHistory *job = getJobHistory();
  const IService* psvc = &svc;
  map<const IService*, ServiceHistory*>::const_iterator itr = 
    m_svcmap.find(psvc);
  if (itr == m_svcmap.end()) {

#ifndef NDEBUG
    m_log << MSG::DEBUG << "Registering Service: ";
    m_log.setColor(MSG::CYAN);
    m_log << svc.name() << endreq;
#endif

    m_svcs.insert(psvc);

    ServiceHistory *svcHist = new ServiceHistory(&svc, job);
    m_svcmap[psvc] = svcHist;

    (const_cast<IService*>(psvc))->addRef();

  }

  m_log.resetColor();
  return StatusCode(StatusCode::SUCCESS,true);

}

StatusCode HistorySvc::listProperties

(

const IService &

svc

)

const [virtual]

Implements IHistorySvc.

Definition at line 782 of file HistorySvc.cpp.

                                                    {

  m_log << MSG::INFO << "Dumping properties for " << svc.name() << endl;

  ServiceHistory *hist = getServiceHistory( svc );

  if (hist == 0) {
    return StatusCode::FAILURE;
  }

  ostringstream ost;
  ost << *hist;

  std::string str = ost.str();

  m_log << MSG::INFO << svc.name() << " --> " << endl << str << endreq;
  
  

  return StatusCode(StatusCode::SUCCESS,true);

}

ServiceHistory * HistorySvc::getServiceHistory

(

const IService &

svc

)

const [virtual]

Implements IHistorySvc.

Definition at line 751 of file HistorySvc.cpp.

                                                       {

  const IService *psvc = &svc;
  map<const IService*, ServiceHistory*>::const_iterator itr = 
    m_svcmap.find(psvc);
  if ( itr == m_svcmap.end() ) {
    m_log << MSG::WARNING << "Service " << svc.name() << " not registered"
          << endreq;
    return 0;
  }

  return ( itr->second );

}

void HistorySvc::getServiceHistory

(

std::set< ServiceHistory * > &

svcs

)

const [virtual]

Implements IHistorySvc.

Definition at line 768 of file HistorySvc.cpp.

                                                                 {

  set<const IService*>::const_iterator itr;
  for (itr=m_svcs.begin(); itr!=m_svcs.end(); ++itr) {
    ServiceHistory *sh = m_svcmap.find( *itr )->second;

    svcs.insert(sh);
  }

}

StatusCode HistorySvc::registerAlg

(

const Algorithm &

alg

)

[virtual]

Implements IHistorySvc.

Definition at line 357 of file HistorySvc.cpp.

                                            {

  JobHistory *job = getJobHistory();
  if (m_algmap.find(&alg) != m_algmap.end()) {
    m_log << MSG::WARNING << "Algorithm " << alg.name()
          << " already registered with HistorySvc" << endreq;
    return StatusCode::SUCCESS;
  }

  (const_cast<Algorithm*>(&alg))->addRef();

  m_algs.insert(&alg);

  AlgorithmHistory *algHist = new AlgorithmHistory(alg, job);
  m_algmap[&alg] = algHist;

#ifndef NDEBUG
  m_log << MSG::DEBUG << "Registering algorithm: ";
  m_log.setColor(MSG::CYAN);
  m_log << alg.name() << endreq;
  m_log.resetColor();
#endif

  return StatusCode(StatusCode::SUCCESS,true);

}

StatusCode HistorySvc::listProperties

(

const Algorithm &

alg

)

const [virtual]

Implements IHistorySvc.

Definition at line 386 of file HistorySvc.cpp.

                                                     {

  m_log << MSG::INFO << "Dumping properties for " << alg.name() << endl;

  AlgorithmHistory *hist = getAlgHistory( alg );

  if (hist == 0) {
    return StatusCode::FAILURE;
  }

  ostringstream ost;
  ost << *hist;

  std::string str = ost.str();

  m_log << MSG::INFO << alg.name() << " --> " << endl << str << endreq;

  return StatusCode(StatusCode::SUCCESS,true);

}

AlgorithmHistory * HistorySvc::getAlgHistory

(

const Algorithm &

alg

)

const [virtual]

Implements IHistorySvc.

Definition at line 426 of file HistorySvc.cpp.

                                                    {

  const Algorithm *palg = &alg;
  set<const Algorithm*>::const_iterator itr = m_algs.find(palg);
  if ( itr == m_algs.end() ) {
    m_log << MSG::WARNING << "Algorithm " << alg.name() << " not registered"
          << endreq;
    return 0;
  }

  map<const Algorithm*, AlgorithmHistory*>::const_iterator itr2;
  itr2 = m_algmap.find( *itr );

  return ( itr2->second );

}

void HistorySvc::getAlgHistory

(

std::set< AlgorithmHistory * > &

algs

)

const [virtual]

Implements IHistorySvc.

Definition at line 445 of file HistorySvc.cpp.

                                                               {

  set<const Algorithm*>::const_iterator itr;
  for (itr=m_algs.begin(); itr!=m_algs.end(); ++itr) {
    AlgorithmHistory *ah = m_algmap.find(*itr)->second;

    algs.insert(ah);
  }

}

StatusCode HistorySvc::registerAlgTool

(

const IAlgTool &

ialg

)

[virtual]

Implements IHistorySvc.

Definition at line 826 of file HistorySvc.cpp.

                                                {
   
  if (! m_isInitialized) {
    if (p_algCtxSvc == 0) {
      if ( service("AlgContextSvc",p_algCtxSvc,true).isFailure() ) {
        m_log << MSG::ERROR << "unable to get the AlgContextSvc" << endreq;
        return StatusCode::FAILURE;
      }
    }

    m_ialgtools.insert(&ialg);
    return StatusCode::SUCCESS;
  }

  const AlgTool *alg = dynamic_cast<const AlgTool*>( &ialg );
  if ( alg == 0 ) {
    m_log << MSG::ERROR << "Could not dcast IAlgTool \"" << ialg.name()
          << "\" to an AlgTool" << endreq;
    return StatusCode::FAILURE;
  }

  if (m_algtools.find(alg) != m_algtools.end()) {
    m_log << MSG::WARNING << "AlgTool " << ialg.name() 
          << " already registered in HistorySvc" << endreq;
    return StatusCode::SUCCESS;
  }

  m_algtools.insert(alg);
  (const_cast<AlgTool*>(alg))->addRef();

  const JobHistory *job = getJobHistory();
  AlgToolHistory *algHist = new AlgToolHistory(*alg, job);
  m_algtoolmap[alg] = algHist;

#ifndef NDEBUG
  m_log << MSG::DEBUG << "Registering algtool: ";
  m_log.setColor(MSG::CYAN);
  m_log << alg->name() << endreq;
  m_log.resetColor();
#endif

  return StatusCode::SUCCESS;

}

StatusCode HistorySvc::listProperties

(

const IAlgTool &

alg

)

const [virtual]

Implements IHistorySvc.

Definition at line 874 of file HistorySvc.cpp.

                                                    {

  m_log << MSG::INFO << "Dumping properties for " << alg.name() << endl;

  AlgToolHistory *hist = getAlgToolHistory( alg );

  if (hist == 0) {
    return StatusCode::FAILURE;
  }

  ostringstream ost;
  ost << *hist;

  std::string str = ost.str();

  m_log << MSG::INFO << alg.name() << " --> " << endl << str << endreq;
 
  return StatusCode::SUCCESS;

}

AlgToolHistory * HistorySvc::getAlgToolHistory

(

const IAlgTool &

alg

)

const [virtual]

Implements IHistorySvc.

Definition at line 915 of file HistorySvc.cpp.

                                                       {

  const AlgTool *palg = dynamic_cast<const AlgTool*>(&alg);
  set<const AlgTool*>::const_iterator itr = m_algtools.find(palg);
  if ( itr == m_algtools.end() ) {
    m_log << MSG::WARNING << "AlgTool " << alg.name() << " not registered"
          << endreq;
    return 0;
  }

  map<const AlgTool*, AlgToolHistory*>::const_iterator itr2;
  itr2 = m_algtoolmap.find( *itr );

  return ( itr2->second );

}

void HistorySvc::getAlgToolHistory

(

std::set< AlgToolHistory * > &

algs

)

const [virtual]

Implements IHistorySvc.

Definition at line 935 of file HistorySvc.cpp.

                                                                 {

  set<const AlgTool*>::const_iterator itr;
  for (itr=m_algtools.begin(); itr!=m_algtools.end(); ++itr) {
    AlgToolHistory *ah = m_algtoolmap.find(*itr)->second;

    algs.insert(ah);
  }

}

DataHistory * HistorySvc::createDataHistoryObj	(	const CLID &	id,
		const std::string &	key,
		const std::string &	store
	)			[virtual]

Implements IHistorySvc.

Definition at line 592 of file HistorySvc.cpp.

                                                                   {

  if (!m_activate) return 0;
  

  AlgorithmHistory *algHist;

  IAlgorithm* ialg = getCurrentIAlg();
  if (ialg == 0) {
#ifndef NDEBUG
    m_log << MSG::DEBUG
          << "Could not discover current Algorithm:" << endl
          << "          object CLID: " << id << "  key: \"" << key 
          << "\"" << endreq;
#endif
    algHist = 0;
  } else {
    Algorithm* alg = dynamic_cast<Algorithm*>(ialg);
    if (alg != 0) {
      algHist = getAlgHistory( *alg );
    } else {
      m_log << MSG::WARNING
            << "Could not extract concerete Algorithm:"
            << endl
            << "          object CLID: " << id << "  key: \"" << key 
            << "\"" << endreq;
      algHist = 0;
    }
  }

  DataHistory *hist = new DataHistory(id, key, algHist);

  return hist;

}

StatusCode HistorySvc::registerDataHistory	(	const CLID &	id,
		const std::string &	key,
		const std::string &	store
	)			[virtual]

Definition at line 631 of file HistorySvc.cpp.

                                                            {

  DHH dhh(id,key);

  pair<DHMitr,DHMitr> mitr = m_datMap.equal_range(dhh);
  
  if (mitr.first == mitr.second) {
    // not in the map
    DataHistory *dh = createDataHistoryObj(id,key,storeName);
    m_datMap.insert(pair<DHH,DataHistory*>(dhh,dh));
  } else {
    // found at least one
    bool match(false);

    std::string algName;
    IAlgorithm *ialg = getCurrentIAlg();
    if (ialg != 0) {
      algName = ialg->name();
    } else {
      algName = "UNKNOWN";
    }

    for (DHMitr itr = mitr.first; itr != mitr.second; ++itr) {
      DataHistory *dh = itr->second;
      if (dh->algorithmHistory()->algorithm_name() == algName) {
        match = true;
        break;
      }
    }

    if (! match) {
      DataHistory *dh = createDataHistoryObj(id,key,storeName);
      m_datMap.insert(pair<DHH,DataHistory*>(dhh,dh));
    }
  }

  return StatusCode::SUCCESS;

}

DataHistory * HistorySvc::getDataHistory	(	const CLID &	id,
		const std::string &	key,
		const std::string &	store
	)			const [virtual]

Implements IHistorySvc.

Definition at line 675 of file HistorySvc.cpp.

                                                                 {

  DHH dhh(id,key);

  pair<DHMCitr,DHMCitr> mitr = m_datMap.equal_range(dhh);

  if(mitr.first == mitr.second) {
    return 0;
  }

  return mitr.first->second;
      
}

int HistorySvc::getDataHistory	(	const CLID &	id,
		const std::string &	key,
		const std::string &	storeName,
		std::list< DataHistory * > &	dhlist
	)			const [virtual]

Definition at line 693 of file HistorySvc.cpp.

                                                                {

  DHH dhh(id,key);

  int n(0);

  pair<DHMCitr,DHMCitr> mitr = m_datMap.equal_range(dhh);

  for (DHMCitr itr=mitr.first; itr != mitr.second; ++itr) {
    dhlist.push_back(itr->second);
    n++;
  }

  return n;

}

void HistorySvc::handle

(

const Incident &

)

[virtual]

Inform that a new incident has occured.

Implements IIncidentListener.

Definition at line 949 of file HistorySvc.cpp.

                                           {

  if (incident.type() == IncidentType::BeginEvent) {
    if (captureState().isFailure()) {
      m_log << MSG::WARNING << "Error capturing state." << endl
            << "Will try again at next BeginEvent incident" << endreq;
    }
  }

}

void HistorySvc::clearState

(

)

[private]

Definition at line 109 of file HistorySvc.cpp.

                            {
  m_algs.clear();
  std::map<const Algorithm*, AlgorithmHistory*>::iterator algitr;
  for (algitr = m_algmap.begin(); algitr != m_algmap.end(); ++algitr) {
    AlgorithmHistory* h = algitr->second;
    (const_cast<Algorithm*> (algitr->first))->release();
    delete h;
  }
  m_algmap.clear();

  m_ialgtools.clear();
  m_algtools.clear();
  std::map<const AlgTool*, AlgToolHistory*>::iterator atitr;
  for (atitr=m_algtoolmap.begin(); atitr != m_algtoolmap.end(); ++atitr) {
    (const_cast<AlgTool*> (atitr->first))->release();
    delete atitr->second;
  }
  m_algtoolmap.clear();

  m_svcs.clear();
  std::map<const IService*, ServiceHistory*>::iterator svitr;
  for (svitr = m_svcmap.begin(); svitr != m_svcmap.end(); ++svitr) {
    (const_cast<IService*> (svitr->first))->release();
    delete svitr->second;
  }
  m_svcmap.clear();
}

void HistorySvc::dumpProperties

(

std::ofstream &

ofs

)

const [private]

Definition at line 525 of file HistorySvc.cpp.

                                                 {


  ofs << "GLOBAL" << std::endl;
  const JobHistory::PropertyList props = m_jobHistory->properties();
  JobHistory::PropertyList::const_iterator itrj;
  for (itrj=props.begin(); itrj != props.end(); ++itrj) {
    std::string client = itrj->first;
    const Property* prp = itrj->second; 
    ofs << client << "  " << dumpProp(prp) << std::endl;
  }
  
  ofs << std::endl << "SERVICES" << std::endl;
  std::map<const IService*, ServiceHistory*>::const_iterator itr_s;
  for (itr_s=m_svcmap.begin(); itr_s != m_svcmap.end(); ++itr_s) {
    const IService* svc = itr_s->first;

    dumpProperties( *svc, ofs );

  }

  ofs << std::endl << "ALGORITHMS" << std::endl;
  std::map<const Algorithm*, AlgorithmHistory*>::const_iterator itr;
  for (itr=m_algmap.begin(); itr != m_algmap.end(); ++itr) {
    const Algorithm* alg = itr->first;

    dumpProperties( *alg, ofs );

  }

  ofs << std::endl << "ALGTOOLS" << std::endl;
  std::map<const AlgTool*, AlgToolHistory*>::const_iterator itr_a;
  for (itr_a=m_algtoolmap.begin(); itr_a != m_algtoolmap.end(); ++itr_a) {
    const AlgTool* alg = itr_a->first;

    dumpProperties( *alg, ofs );

  }


}

void HistorySvc::dumpProperties	(	const IService &	svc,
		std::ofstream &	ofs
	)			const [private]

Definition at line 808 of file HistorySvc.cpp.

                                                                      {

  ServiceHistory *hist = getServiceHistory( svc );

  if (hist == 0) {
    return;
  }

  ServiceHistory::PropertyList::const_iterator itr;
  for (itr=hist->properties().begin(); itr != hist->properties().end();++itr) {
    ofs << svc.name() << "  " << dumpProp(*itr) << std::endl;
  }

}

void HistorySvc::dumpProperties	(	const Algorithm &	alg,
		std::ofstream &	ofs
	)			const [private]

Definition at line 409 of file HistorySvc.cpp.

                                                                       {

  AlgorithmHistory *hist = getAlgHistory( alg );

  if (hist == 0) {
    return;
  }

  AlgorithmHistory::PropertyList::const_iterator itr;
  for (itr=hist->properties().begin(); itr!=hist->properties().end(); ++itr) {
    ofs << alg.name() << "  " << dumpProp(*itr) << std::endl;
  }

}

void HistorySvc::dumpProperties	(	const IAlgTool &	alg,
		std::ofstream &	ofs
	)			const [private]

Definition at line 897 of file HistorySvc.cpp.

                                                                      {

  AlgToolHistory *hist = getAlgToolHistory( alg );

  if (hist == 0) {
    return;
  }

  AlgToolHistory::PropertyList::const_iterator itr;
  for (itr=hist->properties().begin(); itr!=hist->properties().end(); ++itr) {
    ofs << alg.name() << "  " << dumpProp(*itr) << std::endl;
  }

}

void HistorySvc::dumpState

(

std::ofstream &

ofs

)

const [private]

Definition at line 973 of file HistorySvc.cpp.

                                            {


  ofs << "GLOBAL" << std::endl;
  const JobHistory::PropertyList props = m_jobHistory->properties();
  JobHistory::PropertyList::const_iterator itrj;
  for (itrj=props.begin(); itrj != props.end(); ++itrj) {
    std::string client = itrj->first;
    const Property* prp = itrj->second; 
    ofs << client << "  " << dumpProp(prp) << std::endl;
  }
  

  ofs << "SERVICES" << std::endl;
  std::map<const IService*, ServiceHistory*>::const_iterator itr_s;
  for (itr_s=m_svcmap.begin(); itr_s != m_svcmap.end(); ++itr_s) {
    const IService* svc = itr_s->first;

    dumpState( *svc, ofs );

  }

  ofs << "ALGORITHMS" << std::endl;
  std::map<const Algorithm*, AlgorithmHistory*>::const_iterator itr;
  for (itr=m_algmap.begin(); itr != m_algmap.end(); ++itr) {
    const Algorithm* alg = itr->first;

    dumpState( *alg, ofs );

  }


  ofs << "ALGTOOLS" << std::endl;
  std::map<const AlgTool*, AlgToolHistory*>::const_iterator itr_a;
  for (itr_a=m_algtoolmap.begin(); itr_a != m_algtoolmap.end(); ++itr_a) {
    const AlgTool* alg = itr_a->first;

    dumpState( *alg, ofs );

  }

}

void HistorySvc::dumpState	(	const IService &	svc,
		std::ofstream &	ofs
	)			const [private]

Definition at line 1034 of file HistorySvc.cpp.

                                                                 {

  ServiceHistory *hist = getServiceHistory( svc );

  if (hist == 0) {
    return;
  }

  ofs << ">> " << svc.name() << endl << *hist << endl;

}

void HistorySvc::dumpState	(	const Algorithm &	alg,
		std::ofstream &	ofs
	)			const [private]

Definition at line 1019 of file HistorySvc.cpp.

                                                                  {

  AlgorithmHistory *hist = getAlgHistory( alg );

  if (hist == 0) {
    return;
  }

  ofs << ">> " << alg.name() << endl << *hist << endl;

}

void HistorySvc::dumpState	(	const IAlgTool &	alg,
		std::ofstream &	ofs
	)			const [private]

Definition at line 1049 of file HistorySvc.cpp.

                                                                 {

  AlgToolHistory *hist = getAlgToolHistory( alg );

  if (hist == 0) {
    return;
  }

  ofs << ">> " << alg.name() << endl << *hist << endl;

}

std::string HistorySvc::dumpProp

(

const Property *

prop

)

const [private]

Definition at line 964 of file HistorySvc.cpp.

                                               {
  std::ostringstream ost;
  prop->fillStream(ost);
  return ost.str();
}

IAlgorithm * HistorySvc::getCurrentIAlg

(

)

const [private]

Definition at line 577 of file HistorySvc.cpp.

                                 {
  if (p_algCtxSvc == 0) {
    m_log << MSG::WARNING << "trying to create DataHistoryObj before "
          << "HistorySvc has been initialized" << endreq;
    return 0;

  } else {
    return p_algCtxSvc->currentAlg();
  }
}

---

Friends And Related Function Documentation

friend class SvcFactory< HistorySvc > [friend]

Definition at line 112 of file HistorySvc.h.

---

Member Data Documentation

bool HistorySvc::m_isInitialized [private]

Definition at line 114 of file HistorySvc.h.

bool HistorySvc::m_dump [private]

Definition at line 115 of file HistorySvc.h.

bool HistorySvc::m_activate [private]

Definition at line 116 of file HistorySvc.h.

IAlgContextSvc* HistorySvc::p_algCtxSvc [private]

Definition at line 118 of file HistorySvc.h.

std::set<const Algorithm*> HistorySvc::m_algs [private]

Definition at line 120 of file HistorySvc.h.

std::map<const Algorithm*, AlgorithmHistory*> HistorySvc::m_algmap [private]

Definition at line 121 of file HistorySvc.h.

std::set<const IAlgTool*> HistorySvc::m_ialgtools [private]

Definition at line 123 of file HistorySvc.h.

std::set<const AlgTool*> HistorySvc::m_algtools [private]

Definition at line 124 of file HistorySvc.h.

std::map<const AlgTool*, AlgToolHistory*> HistorySvc::m_algtoolmap [private]

Definition at line 125 of file HistorySvc.h.

std::set<const IService*> HistorySvc::m_svcs [private]

Definition at line 127 of file HistorySvc.h.

std::map<const IService*, ServiceHistory*> HistorySvc::m_svcmap [private]

Definition at line 128 of file HistorySvc.h.

std::multimap<DHH, DataHistory*> HistorySvc::m_datMap [private]

Definition at line 130 of file HistorySvc.h.

JobHistory* HistorySvc::m_jobHistory [private]

Definition at line 134 of file HistorySvc.h.

std::string HistorySvc::m_outputFile [private]

Definition at line 136 of file HistorySvc.h.

IIncidentSvc* HistorySvc::m_incidentSvc [private]

Definition at line 152 of file HistorySvc.h.

MsgStream HistorySvc::m_log [mutable, private]

Definition at line 154 of file HistorySvc.h.

---

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

• /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v20r4/GaudiSvc/src/HistorySvc/HistorySvc.h
• /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v20r4/GaudiSvc/src/HistorySvc/HistorySvc.cpp