| # Gaudi Framework, version v21r7 |

Home |  | Generated: 22 Jan 2010

# HistorySvc Class Reference

HistorySvc class definition. More...

`#include <HistorySvc.h>`

Inheritance diagram for HistorySvc:

[legend]
Collaboration diagram for HistorySvc:

[legend]

List of all members.

## Public Member Functions
virtual StatusCode | initialize ()
virtual StatusCode | reinitialize ()
virtual StatusCode | finalize ()
virtual StatusCode | captureState ()
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)
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 >

## Detailed Description

HistorySvc class definition.

Definition at line 45 of file HistorySvc.h.

## Member Typedef Documentation

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

Definition at line 97 of file HistorySvc.h.

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

Definition at line 98 of file HistorySvc.h.

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

Definition at line 99 of file HistorySvc.h.

## Constructor & Destructor Documentation

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

Definition at line 69 of file HistorySvc.cpp.

    00070   : base_class( name, svc ),
    00071     m_isInitialized(false),
    00072     m_dump(false),
    00073     p_algCtxSvc(0),
    00074     m_jobHistory(0),
    00075     m_outputFile(""),
    00076     m_incidentSvc(0),
    00077     m_log(msgSvc(), name )
    00078
    00079 {
    00080     declareProperty("Dump",m_dump);
    00081     declareProperty("Activate", m_activate=true);
    00082     declareProperty("OutputFile",m_outputFile);
    00083
    00084     // hack to bring in environ
    00085     vector<string> envtmp = System::getEnv();
    00086
    00087 }

HistorySvc::~HistorySvc | ( |  | ) | `[virtual]`

Definition at line 91 of file HistorySvc.cpp.

    00091                         {
    00092   delete m_jobHistory;
    00093 }

## Member Function Documentation

StatusCode HistorySvc::initialize | ( |  | ) | `[virtual]`

Reimplemented from Service.

Definition at line 140 of file HistorySvc.cpp.

    00140                                   {
    00141
    00142   StatusCode status = Service::initialize();
    00143   m_log.setLevel( m_outputLevel.value() );
    00144
    00145   if (status.isFailure()) {
    00146 #ifndef NDEBUG
    00147     m_log << MSG::DEBUG << "Failed to initialize the base class (Service)"
    00148           << endmsg;
    00149 #endif
    00150     return status;
    00151   }
    00152
    00153 #ifndef NDEBUG
    00154   m_log << MSG::DEBUG << "Initializing HistorySvc" << endmsg;
    00155 #endif
    00156
    00157   if (!m_activate) return StatusCode::SUCCESS;
    00158
    00159   static const bool CREATEIF(true);
    00160
    00161   if ( service("AlgContextSvc",p_algCtxSvc,CREATEIF).isFailure() ) {
    00162     m_log << MSG::ERROR << "unable to get the AlgContextSvc" << endmsg;
    00163     return StatusCode::FAILURE;
    00164   }
    00165
    00166   if (service("IncidentSvc", m_incidentSvc, CREATEIF).isFailure()) {
    00167     m_log << MSG::ERROR << "unable to get the IncidentSvc" << endmsg;
    00168     return StatusCode::FAILURE;
    00169   }
    00170
    00171   // create a weak dependency on the ToolSvc, so that it doesn't get deleted
    00172   // before we're done with it in finalize
    00173   if (ServiceHandle<IToolSvc>("ToolSvc/ToolSvc",name()).retrieve().isFailure()) {
    00174     m_log << MSG::ERROR << "could not retrieve the ToolSvc handle !"
    00175           << endmsg;
    00176     return StatusCode::FAILURE;
    00177   }
    00178
    00179   // add listener to be triggered by first BeginEvent with low priority
    00180   // so it gets called first
    00181   const bool rethrow = false;
    00182   const bool oneShot = true; // make the listener called only once
    00183   m_incidentSvc->addListener(this,IncidentType::BeginEvent,
    00184                              std::numeric_limits<long>::min(),rethrow,oneShot);
    00185
    00186   m_isInitialized = true;
    00187
    00188   return StatusCode::SUCCESS;
    00189
    00190 }

StatusCode HistorySvc::reinitialize | ( |  | ) | `[virtual]`

Reimplemented from Service.

Definition at line 97 of file HistorySvc.cpp.

    00097                                     {
    00098
    00099   clearState();
    00100
    00101   m_state = Gaudi::StateMachine::OFFLINE;
    00102
    00103   return initialize();
    00104
    00105 }

StatusCode HistorySvc::finalize | ( | void |  | ) | `[virtual]`

Reimplemented from Service.

Definition at line 297 of file HistorySvc.cpp.

    00297                                 {
    00298
    00299   if (!m_activate) return StatusCode::SUCCESS;
    00300
    00301   if (m_dump) {
    00302     listProperties().ignore();
    00303   }
    00304
    00305   if (m_outputFile != "") {
    00306     std::ofstream ofs;
    00307     ofs.open(m_outputFile.c_str());
    00308     if (!ofs) {
    00309       m_log << MSG::ERROR << "Unable to open output file \"m_outputFile\""
    00310             << endmsg;
    00311     } else {
    00312
    00313       //      dumpProperties(ofs);
    00314       dumpState(ofs);
    00315
    00316       ofs.close();
    00317     }
    00318   }
    00319
    00320   clearState();
    00321
    00322   StatusCode status = Service::finalize();
    00323
    00324   if ( status.isSuccess() )
    00325     m_log << MSG::INFO << "Service finalised successfully" << endmsg;
    00326
    00327   return status;
    00328
    00329 }

StatusCode HistorySvc::captureState | ( |  | ) | `[virtual]`

Get all the Algorithms

Get all the AlgTools

Get all the Services

Definition at line 193 of file HistorySvc.cpp.

    00193                                     {
    00194
    00195   if (m_jobHistory == 0) {
    00196     m_jobHistory = new JobHistory;
    00197     IJobOptionsSvc *jo;
    00198     if (service("JobOptionsSvc",jo).isFailure()) {
    00199        m_log << MSG::ERROR
    00200              << "Could not get jobOptionsSvc - "
    00201              << "not adding properties to JobHistory" << endmsg;
    00202     } else {
    00203
    00204       bool foundAppMgr(false);
    00205
    00206       std::vector<std::string> clients = jo->getClients();
    00207       std::vector<std::string>::const_iterator it;
    00208       std::vector<const Property*>::const_iterator itr;
    00209       for (it=clients.begin(); it!=clients.end(); ++it) {
    00210         if (*it == "ApplicationMgr") {
    00211           foundAppMgr = true;
    00212         }
    00213         const std::vector<const Property*> *props = jo->getProperties(*it);
    00214         for (itr=props->begin(); itr != props->end(); ++itr) {
    00215           m_jobHistory->addProperty( *it, *itr );
    00216         }
    00217       }
    00218
    00219       if (!foundAppMgr) {
    00220         IProperty *ap;
    00221         if (service("ApplicationMgr",ap).isFailure()) {
    00222           m_log << MSG::ERROR << "could not get the ApplicationMgr" << endmsg;
    00223         } else {
    00224           std::vector<Property*>::const_iterator itr2;
    00225           const std::vector<Property*> props = ap->getProperties();
    00226           for (itr2=props.begin(); itr2 != props.end(); ++itr2) {
    00227             m_jobHistory->addProperty( "ApplicationMgr", *itr2 );
    00228           }
    00229         }
    00230       }
    00231
    00232     }
    00233   }
    00234
    00236
    00237   StatusCode sc;
    00238   IAlgManager* algMgr = 0;
    00239   sc = Gaudi::svcLocator()->queryInterface( IAlgManager::interfaceID(),
    00240                                             pp_cast<void>(&algMgr) );
    00241   if (sc.isFailure()) {
    00242     m_log << MSG::ERROR << "Could not get AlgManager" << endmsg;
    00243     return StatusCode::FAILURE;
    00244   } else {
    00245
    00246     std::list<IAlgorithm*> algs;
    00247     algs = algMgr->getAlgorithms();
    00248     std::list<IAlgorithm*>::const_iterator itr;
    00249     for (itr=algs.begin(); itr!=algs.end(); ++itr) {
    00250       Algorithm* alg = dynamic_cast<Algorithm*> (*itr);
    00251       if (alg == 0) {
    00252         m_log << MSG::WARNING << "Algorithm " << (*itr)->name()
    00253               << " does not inherit from Algorithm. Not registering it."
    00254               << endmsg;
    00255       } else {
    00256         registerAlg( *alg ).ignore();
    00257       }
    00258     }
    00259
    00260     m_log << MSG::INFO;
    00261     m_log << "Registered " << algs.size() << " Algorithms" << endmsg;
    00262
    00263   }
    00264
    00266
    00267   m_isInitialized = true;
    00268   std::set<const IAlgTool*>::const_iterator itra;
    00269   for (itra = m_ialgtools.begin(); itra != m_ialgtools.end(); ++itra) {
    00270     (const_cast<IAlgTool*>(*itra))->addRef();
    00271     registerAlgTool(**itra).ignore();
    00272   }
    00273
    00274   m_log << MSG::INFO << "Registered " << m_algtools.size() << " AlgTools"
    00275         << endmsg;
    00276
    00278
    00279   std::list<IService*> svcs = Gaudi::svcLocator()->getServices();
    00280
    00281   std::list<IService*>::const_iterator itrs;
    00282   for (itrs=svcs.begin(); itrs!=svcs.end(); ++itrs) {
    00283     (*itrs)->addRef();
    00284     registerSvc(**itrs).ignore();
    00285   }
    00286
    00287   m_log << MSG::INFO;
    00288   m_log << "Registered " << svcs.size() << " Services" << endmsg;
    00289
    00290   return StatusCode::SUCCESS;
    00291
    00292
    00293 }

StatusCode HistorySvc::registerJob | ( |  | ) | `[virtual]`

Definition at line 439 of file HistorySvc.cpp.

    00439                         {
    00440
    00441
    00442   return StatusCode(StatusCode::SUCCESS,true);
    00443
    00444
    00445 }

StatusCode HistorySvc::listProperties | ( |  | ) | const`[virtual]`

Definition at line 450 of file HistorySvc.cpp.

    00450                                  {
    00451
    00452   m_log << MSG::INFO;
    00453   m_log.setColor(MSG::CYAN);
    00454   m_log << "Dumping properties for all Algorithms" << endmsg;
    00455
    00456   std::map<const Algorithm*, AlgorithmHistory*>::const_iterator itr;
    00457   for (itr=m_algmap.begin(); itr != m_algmap.end(); ++itr) {
    00458     const Algorithm* alg = itr->first;
    00459
    00460     listProperties( *alg ).ignore();
    00461
    00462   }
    00463
    00464   m_log << MSG::INFO;
    00465   m_log.setColor(MSG::CYAN);
    00466   m_log << "Dumping properties for all AlgTools" << endmsg;
    00467
    00468   std::map<const AlgTool*, AlgToolHistory*>::const_iterator itr_a;
    00469   for (itr_a=m_algtoolmap.begin(); itr_a != m_algtoolmap.end(); ++itr_a) {
    00470     const AlgTool* alg = itr_a->first;
    00471
    00472     listProperties( *alg ).ignore();
    00473
    00474   }
    00475
    00476   m_log << MSG::INFO;
    00477   m_log.setColor(MSG::CYAN);
    00478   m_log << "Dumping properties for all Services" << endmsg;
    00479
    00480   std::map<const IService*, ServiceHistory*>::const_iterator itr_s;
    00481   for (itr_s=m_svcmap.begin(); itr_s != m_svcmap.end(); ++itr_s) {
    00482     const IService* svc = itr_s->first;
    00483
    00484     listProperties( *svc ).ignore();
    00485
    00486   }
    00487
    00488   m_log << MSG::INFO;
    00489   m_log.setColor(MSG::CYAN);
    00490   m_log << "Dumping properties for Job";
    00491   m_log.resetColor();
    00492
    00493   ostringstream ost;
    00494   ost << *m_jobHistory;
    00495   std::string str = ost.str();
    00496
    00497   m_log << std::endl << str << endmsg;
    00498
    00499   return StatusCode(StatusCode::SUCCESS,true);
    00500
    00501 }

JobHistory * HistorySvc::getJobHistory | ( |  | ) | const`[virtual]`

Definition at line 549 of file HistorySvc.cpp.

    00549                                 {
    00550
    00551   return m_jobHistory;
    00552
    00553 }

StatusCode HistorySvc::registerSvc | ( | const IService & | svc | ) | `[virtual]`

Definition at line 695 of file HistorySvc.cpp.

    00695                                            {
    00696
    00697   if ( svc.name() == "HistoryStore" ) {
    00698     //    m_log << MSG::WARNING << "not registering store" << endmsg;
    00699     return StatusCode(StatusCode::SUCCESS,true);
    00700   }
    00701
    00702   JobHistory *job = getJobHistory();
    00703   const IService* psvc = &svc;
    00704   map<const IService*, ServiceHistory*>::const_iterator itr =
    00705     m_svcmap.find(psvc);
    00706   if (itr == m_svcmap.end()) {
    00707
    00708 #ifndef NDEBUG
    00709     m_log << MSG::DEBUG << "Registering Service: ";
    00710     m_log.setColor(MSG::CYAN);
    00711     m_log << svc.name() << endmsg;
    00712 #endif
    00713
    00714     m_svcs.insert(psvc);
    00715
    00716     ServiceHistory *svcHist = new ServiceHistory(&svc, job);
    00717     m_svcmap[psvc] = svcHist;
    00718
    00719     (const_cast<IService*>(psvc))->addRef();
    00720
    00721   }
    00722
    00723   m_log.resetColor();
    00724   return StatusCode(StatusCode::SUCCESS,true);
    00725
    00726 }

StatusCode HistorySvc::listProperties | ( | const IService & | svc | ) | const`[virtual]`

Definition at line 762 of file HistorySvc.cpp.

    00762                                                     {
    00763
    00764   m_log << MSG::INFO << "Dumping properties for " << svc.name() << endl;
    00765
    00766   ServiceHistory *hist = getServiceHistory( svc );
    00767
    00768   if (hist == 0) {
    00769     return StatusCode::FAILURE;
    00770   }
    00771
    00772   ostringstream ost;
    00773   ost << *hist;
    00774
    00775   std::string str = ost.str();
    00776
    00777   m_log << MSG::INFO << svc.name() << " --> " << endl << str << endmsg;
    00778
    00779
    00780
    00781   return StatusCode(StatusCode::SUCCESS,true);
    00782
    00783 }

ServiceHistory * HistorySvc::getServiceHistory | ( | const IService & | svc | ) | const`[virtual]`

Definition at line 731 of file HistorySvc.cpp.

    00731                                                        {
    00732
    00733   const IService *psvc = &svc;
    00734   map<const IService*, ServiceHistory*>::const_iterator itr =
    00735     m_svcmap.find(psvc);
    00736   if ( itr == m_svcmap.end() ) {
    00737     m_log << MSG::WARNING << "Service " << svc.name() << " not registered"
    00738           << endmsg;
    00739     return 0;
    00740   }
    00741
    00742   return ( itr->second );
    00743
    00744 }

void HistorySvc::getServiceHistory | ( | std::set< ServiceHistory * > & | svcs | ) | const`[virtual]`

Definition at line 748 of file HistorySvc.cpp.

    00748                                                                  {
    00749
    00750   set<const IService*>::const_iterator itr;
    00751   for (itr=m_svcs.begin(); itr!=m_svcs.end(); ++itr) {
    00752     ServiceHistory *sh = m_svcmap.find( *itr )->second;
    00753
    00754     svcs.insert(sh);
    00755   }
    00756
    00757 }

StatusCode HistorySvc::registerAlg | ( | const Algorithm & | alg | ) | `[virtual]`

Definition at line 337 of file HistorySvc.cpp.

    00337                                             {
    00338
    00339   JobHistory *job = getJobHistory();
    00340   if (m_algmap.find(&alg) != m_algmap.end()) {
    00341     m_log << MSG::WARNING << "Algorithm " << alg.name()
    00342           << " already registered with HistorySvc" << endmsg;
    00343     return StatusCode::SUCCESS;
    00344   }
    00345
    00346   (const_cast<Algorithm*>(&alg))->addRef();
    00347
    00348   m_algs.insert(&alg);
    00349
    00350   AlgorithmHistory *algHist = new AlgorithmHistory(alg, job);
    00351   m_algmap[&alg] = algHist;
    00352
    00353 #ifndef NDEBUG
    00354   m_log << MSG::DEBUG << "Registering algorithm: ";
    00355   m_log.setColor(MSG::CYAN);
    00356   m_log << alg.name() << endmsg;
    00357   m_log.resetColor();
    00358 #endif
    00359
    00360   return StatusCode(StatusCode::SUCCESS,true);
    00361
    00362 }

StatusCode HistorySvc::listProperties | ( | const Algorithm & | alg | ) | const`[virtual]`

Definition at line 366 of file HistorySvc.cpp.

    00366                                                      {
    00367
    00368   m_log << MSG::INFO << "Dumping properties for " << alg.name() << endl;
    00369
    00370   AlgorithmHistory *hist = getAlgHistory( alg );
    00371
    00372   if (hist == 0) {
    00373     return StatusCode::FAILURE;
    00374   }
    00375
    00376   ostringstream ost;
    00377   ost << *hist;
    00378
    00379   std::string str = ost.str();
    00380
    00381   m_log << MSG::INFO << alg.name() << " --> " << endl << str << endmsg;
    00382
    00383   return StatusCode(StatusCode::SUCCESS,true);
    00384
    00385 }

AlgorithmHistory * HistorySvc::getAlgHistory | ( | const Algorithm & | alg | ) | const`[virtual]`

Definition at line 406 of file HistorySvc.cpp.

    00406                                                     {
    00407
    00408   const Algorithm *palg = &alg;
    00409   set<const Algorithm*>::const_iterator itr = m_algs.find(palg);
    00410   if ( itr == m_algs.end() ) {
    00411     m_log << MSG::WARNING << "Algorithm " << alg.name() << " not registered"
    00412           << endmsg;
    00413     return 0;
    00414   }
    00415
    00416   map<const Algorithm*, AlgorithmHistory*>::const_iterator itr2;
    00417   itr2 = m_algmap.find( *itr );
    00418
    00419   return ( itr2->second );
    00420
    00421 }

void HistorySvc::getAlgHistory | ( | std::set< AlgorithmHistory * > & | algs | ) | const`[virtual]`

Definition at line 425 of file HistorySvc.cpp.

    00425                                                                {
    00426
    00427   set<const Algorithm*>::const_iterator itr;
    00428   for (itr=m_algs.begin(); itr!=m_algs.end(); ++itr) {
    00429     AlgorithmHistory *ah = m_algmap.find(*itr)->second;
    00430
    00431     algs.insert(ah);
    00432   }
    00433
    00434 }

StatusCode HistorySvc::registerAlgTool | ( | const IAlgTool & | ialg | ) | `[virtual]`

Definition at line 806 of file HistorySvc.cpp.

    00806                                                 {
    00807
    00808   if (! m_isInitialized) {
    00809     if (p_algCtxSvc == 0) {
    00810       if ( service("AlgContextSvc",p_algCtxSvc,true).isFailure() ) {
    00811         m_log << MSG::ERROR << "unable to get the AlgContextSvc" << endmsg;
    00812         return StatusCode::FAILURE;
    00813       }
    00814     }
    00815
    00816     m_ialgtools.insert(&ialg);
    00817     return StatusCode::SUCCESS;
    00818   }
    00819
    00820   const AlgTool *alg = dynamic_cast<const AlgTool*>( &ialg );
    00821   if ( alg == 0 ) {
    00822     m_log << MSG::ERROR << "Could not dcast IAlgTool \"" << ialg.name()
    00823           << "\" to an AlgTool" << endmsg;
    00824     return StatusCode::FAILURE;
    00825   }
    00826
    00827   if (m_algtools.find(alg) != m_algtools.end()) {
    00828     m_log << MSG::WARNING << "AlgTool " << ialg.name()
    00829           << " already registered in HistorySvc" << endmsg;
    00830     return StatusCode::SUCCESS;
    00831   }
    00832
    00833   m_algtools.insert(alg);
    00834   (const_cast<AlgTool*>(alg))->addRef();
    00835
    00836   const JobHistory *job = getJobHistory();
    00837   AlgToolHistory *algHist = new AlgToolHistory(*alg, job);
    00838   m_algtoolmap[alg] = algHist;
    00839
    00840 #ifndef NDEBUG
    00841   m_log << MSG::DEBUG << "Registering algtool: ";
    00842   m_log.setColor(MSG::CYAN);
    00843   m_log << alg->name() << endmsg;
    00844   m_log.resetColor();
    00845 #endif
    00846
    00847   return StatusCode::SUCCESS;
    00848
    00849 }

StatusCode HistorySvc::listProperties | ( | const IAlgTool & | alg | ) | const`[virtual]`

Definition at line 854 of file HistorySvc.cpp.

    00854                                                     {
    00855
    00856   m_log << MSG::INFO << "Dumping properties for " << alg.name() << endl;
    00857
    00858   AlgToolHistory *hist = getAlgToolHistory( alg );
    00859
    00860   if (hist == 0) {
    00861     return StatusCode::FAILURE;
    00862   }
    00863
    00864   ostringstream ost;
    00865   ost << *hist;
    00866
    00867   std::string str = ost.str();
    00868
    00869   m_log << MSG::INFO << alg.name() << " --> " << endl << str << endmsg;
    00870
    00871   return StatusCode::SUCCESS;
    00872
    00873 }

AlgToolHistory * HistorySvc::getAlgToolHistory | ( | const IAlgTool & | alg | ) | const`[virtual]`

Definition at line 895 of file HistorySvc.cpp.

    00895                                                        {
    00896
    00897   const AlgTool *palg = dynamic_cast<const AlgTool*>(&alg);
    00898   set<const AlgTool*>::const_iterator itr = m_algtools.find(palg);
    00899   if ( itr == m_algtools.end() ) {
    00900     m_log << MSG::WARNING << "AlgTool " << alg.name() << " not registered"
    00901           << endmsg;
    00902     return 0;
    00903   }
    00904
    00905   map<const AlgTool*, AlgToolHistory*>::const_iterator itr2;
    00906   itr2 = m_algtoolmap.find( *itr );
    00907
    00908   return ( itr2->second );
    00909
    00910 }

void HistorySvc::getAlgToolHistory | ( | std::set< AlgToolHistory * > & | algs | ) | const`[virtual]`

Definition at line 915 of file HistorySvc.cpp.

    00915                                                                  {
    00916
    00917   set<const AlgTool*>::const_iterator itr;
    00918   for (itr=m_algtools.begin(); itr!=m_algtools.end(); ++itr) {
    00919     AlgToolHistory *ah = m_algtoolmap.find(*itr)->second;
    00920
    00921     algs.insert(ah);
    00922   }
    00923
    00924 }

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

Definition at line 572 of file HistorySvc.cpp.

    00573                                                                    {
    00574
    00575   if (!m_activate) return 0;
    00576
    00577
    00578   AlgorithmHistory *algHist;
    00579
    00580   IAlgorithm* ialg = getCurrentIAlg();
    00581   if (ialg == 0) {
    00582 #ifndef NDEBUG
    00583     m_log << MSG::DEBUG
    00584           << "Could not discover current Algorithm:" << endl
    00585           << "          object CLID: " << id << "  key: \"" << key
    00586           << "\"" << endmsg;
    00587 #endif
    00588     algHist = 0;
    00589   } else {
    00590     Algorithm* alg = dynamic_cast<Algorithm*>(ialg);
    00591     if (alg != 0) {
    00592       algHist = getAlgHistory( *alg );
    00593     } else {
    00594       m_log << MSG::WARNING
    00595             << "Could not extract concerete Algorithm:"
    00596             << endl
    00597             << "          object CLID: " << id << "  key: \"" << key
    00598             << "\"" << endmsg;
    00599       algHist = 0;
    00600     }
    00601   }
    00602
    00603   DataHistory *hist = new DataHistory(id, key, algHist);
    00604
    00605   return hist;
    00606
    00607 }

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

Definition at line 611 of file HistorySvc.cpp.

    00612                                                             {
    00613
    00614   DHH dhh(id,key);
    00615
    00616   pair<DHMitr,DHMitr> mitr = m_datMap.equal_range(dhh);
    00617
    00618   if (mitr.first == mitr.second) {
    00619     // not in the map
    00620     DataHistory *dh = createDataHistoryObj(id,key,storeName);
    00621     m_datMap.insert(pair<DHH,DataHistory*>(dhh,dh));
    00622   } else {
    00623     // found at least one
    00624     bool match(false);
    00625
    00626     std::string algName;
    00627     IAlgorithm *ialg = getCurrentIAlg();
    00628     if (ialg != 0) {
    00629       algName = ialg->name();
    00630     } else {
    00631       algName = "UNKNOWN";
    00632     }
    00633
    00634     for (DHMitr itr = mitr.first; itr != mitr.second; ++itr) {
    00635       DataHistory *dh = itr->second;
    00636       if (dh->algorithmHistory()->algorithm_name() == algName) {
    00637         match = true;
    00638         break;
    00639       }
    00640     }
    00641
    00642     if (! match) {
    00643       DataHistory *dh = createDataHistoryObj(id,key,storeName);
    00644       m_datMap.insert(pair<DHH,DataHistory*>(dhh,dh));
    00645     }
    00646   }
    00647
    00648   return StatusCode::SUCCESS;
    00649
    00650 }

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

Definition at line 655 of file HistorySvc.cpp.

    00656                                                                  {
    00657
    00658   DHH dhh(id,key);
    00659
    00660   pair<DHMCitr,DHMCitr> mitr = m_datMap.equal_range(dhh);
    00661
    00662   if(mitr.first == mitr.second) {
    00663     return 0;
    00664   }
    00665
    00666   return mitr.first->second;
    00667
    00668 }

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

Definition at line 673 of file HistorySvc.cpp.

    00675                                                                 {
    00676
    00677   DHH dhh(id,key);
    00678
    00679   int n(0);
    00680
    00681   pair<DHMCitr,DHMCitr> mitr = m_datMap.equal_range(dhh);
    00682
    00683   for (DHMCitr itr=mitr.first; itr != mitr.second; ++itr) {
    00684     dhlist.push_back(itr->second);
    00685     n++;
    00686   }
    00687
    00688   return n;
    00689
    00690 }

void HistorySvc::handle | ( | const Incident & | inc | ) | `[virtual]`

Definition at line 929 of file HistorySvc.cpp.

    00929                                            {
    00930
    00931   if (incident.type() == IncidentType::BeginEvent) {
    00932     if (captureState().isFailure()) {
    00933       m_log << MSG::WARNING << "Error capturing state." << endl
    00934             << "Will try again at next BeginEvent incident" << endmsg;
    00935     }
    00936   }
    00937
    00938 }

void HistorySvc::clearState | ( |  | ) | `[private]`

Definition at line 109 of file HistorySvc.cpp.

    00109                             {
    00110   m_algs.clear();
    00111   std::map<const Algorithm*, AlgorithmHistory*>::iterator algitr;
    00112   for (algitr = m_algmap.begin(); algitr != m_algmap.end(); ++algitr) {
    00113     AlgorithmHistory* h = algitr->second;
    00114     (const_cast<Algorithm*> (algitr->first))->release();
    00115     delete h;
    00116   }
    00117   m_algmap.clear();
    00118
    00119   m_ialgtools.clear();
    00120   m_algtools.clear();
    00121   std::map<const AlgTool*, AlgToolHistory*>::iterator atitr;
    00122   for (atitr=m_algtoolmap.begin(); atitr != m_algtoolmap.end(); ++atitr) {
    00123     (const_cast<AlgTool*> (atitr->first))->release();
    00124     delete atitr->second;
    00125   }
    00126   m_algtoolmap.clear();
    00127
    00128   m_svcs.clear();
    00129   std::map<const IService*, ServiceHistory*>::iterator svitr;
    00130   for (svitr = m_svcmap.begin(); svitr != m_svcmap.end(); ++svitr) {
    00131     (const_cast<IService*> (svitr->first))->release();
    00132     delete svitr->second;
    00133   }
    00134   m_svcmap.clear();
    00135 }

void HistorySvc::dumpProperties | ( | std::ofstream & | ofs | ) | const`[private]`

Definition at line 505 of file HistorySvc.cpp.

    00505                                                  {
    00506
    00507
    00508   ofs << "GLOBAL" << std::endl;
    00509   const JobHistory::PropertyList props = m_jobHistory->properties();
    00510   JobHistory::PropertyList::const_iterator itrj;
    00511   for (itrj=props.begin(); itrj != props.end(); ++itrj) {
    00512     std::string client = itrj->first;
    00513     const Property* prp = itrj->second;
    00514     ofs << client << "  " << dumpProp(prp) << std::endl;
    00515   }
    00516
    00517   ofs << std::endl << "SERVICES" << std::endl;
    00518   std::map<const IService*, ServiceHistory*>::const_iterator itr_s;
    00519   for (itr_s=m_svcmap.begin(); itr_s != m_svcmap.end(); ++itr_s) {
    00520     const IService* svc = itr_s->first;
    00521
    00522     dumpProperties( *svc, ofs );
    00523
    00524   }
    00525
    00526   ofs << std::endl << "ALGORITHMS" << std::endl;
    00527   std::map<const Algorithm*, AlgorithmHistory*>::const_iterator itr;
    00528   for (itr=m_algmap.begin(); itr != m_algmap.end(); ++itr) {
    00529     const Algorithm* alg = itr->first;
    00530
    00531     dumpProperties( *alg, ofs );
    00532
    00533   }
    00534
    00535   ofs << std::endl << "ALGTOOLS" << std::endl;
    00536   std::map<const AlgTool*, AlgToolHistory*>::const_iterator itr_a;
    00537   for (itr_a=m_algtoolmap.begin(); itr_a != m_algtoolmap.end(); ++itr_a) {
    00538     const AlgTool* alg = itr_a->first;
    00539
    00540     dumpProperties( *alg, ofs );
    00541
    00542   }
    00543
    00544
    00545 }

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

Definition at line 788 of file HistorySvc.cpp.

    00788                                                                       {
    00789
    00790   ServiceHistory *hist = getServiceHistory( svc );
    00791
    00792   if (hist == 0) {
    00793     return;
    00794   }
    00795
    00796   ServiceHistory::PropertyList::const_iterator itr;
    00797   for (itr=hist->properties().begin(); itr != hist->properties().end();++itr) {
    00798     ofs << svc.name() << "  " << dumpProp(*itr) << std::endl;
    00799   }
    00800
    00801 }

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

Definition at line 389 of file HistorySvc.cpp.

    00389                                                                        {
    00390
    00391   AlgorithmHistory *hist = getAlgHistory( alg );
    00392
    00393   if (hist == 0) {
    00394     return;
    00395   }
    00396
    00397   AlgorithmHistory::PropertyList::const_iterator itr;
    00398   for (itr=hist->properties().begin(); itr!=hist->properties().end(); ++itr) {
    00399     ofs << alg.name() << "  " << dumpProp(*itr) << std::endl;
    00400   }
    00401
    00402 }

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

Definition at line 877 of file HistorySvc.cpp.

    00877                                                                       {
    00878
    00879   AlgToolHistory *hist = getAlgToolHistory( alg );
    00880
    00881   if (hist == 0) {
    00882     return;
    00883   }
    00884
    00885   AlgToolHistory::PropertyList::const_iterator itr;
    00886   for (itr=hist->properties().begin(); itr!=hist->properties().end(); ++itr) {
    00887     ofs << alg.name() << "  " << dumpProp(*itr) << std::endl;
    00888   }
    00889
    00890 }

void HistorySvc::dumpState | ( | std::ofstream & | ofs | ) | const`[private]`

Definition at line 953 of file HistorySvc.cpp.

    00953                                             {
    00954
    00955
    00956   ofs << "GLOBAL" << std::endl;
    00957   const JobHistory::PropertyList props = m_jobHistory->properties();
    00958   JobHistory::PropertyList::const_iterator itrj;
    00959   for (itrj=props.begin(); itrj != props.end(); ++itrj) {
    00960     std::string client = itrj->first;
    00961     const Property* prp = itrj->second;
    00962     ofs << client << "  " << dumpProp(prp) << std::endl;
    00963   }
    00964
    00965
    00966   ofs << "SERVICES" << std::endl;
    00967   std::map<const IService*, ServiceHistory*>::const_iterator itr_s;
    00968   for (itr_s=m_svcmap.begin(); itr_s != m_svcmap.end(); ++itr_s) {
    00969     const IService* svc = itr_s->first;
    00970
    00971     dumpState( *svc, ofs );
    00972
    00973   }
    00974
    00975   ofs << "ALGORITHMS" << std::endl;
    00976   std::map<const Algorithm*, AlgorithmHistory*>::const_iterator itr;
    00977   for (itr=m_algmap.begin(); itr != m_algmap.end(); ++itr) {
    00978     const Algorithm* alg = itr->first;
    00979
    00980     dumpState( *alg, ofs );
    00981
    00982   }
    00983
    00984
    00985   ofs << "ALGTOOLS" << std::endl;
    00986   std::map<const AlgTool*, AlgToolHistory*>::const_iterator itr_a;
    00987   for (itr_a=m_algtoolmap.begin(); itr_a != m_algtoolmap.end(); ++itr_a) {
    00988     const AlgTool* alg = itr_a->first;
    00989
    00990     dumpState( *alg, ofs );
    00991
    00992   }
    00993
    00994 }

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

Definition at line 1014 of file HistorySvc.cpp.

    01014                                                                  {
    01015
    01016   ServiceHistory *hist = getServiceHistory( svc );
    01017
    01018   if (hist == 0) {
    01019     return;
    01020   }
    01021
    01022   ofs << ">> " << svc.name() << endl << *hist << endl;
    01023
    01024 }

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

Definition at line 999 of file HistorySvc.cpp.

    00999                                                                   {
    01000
    01001   AlgorithmHistory *hist = getAlgHistory( alg );
    01002
    01003   if (hist == 0) {
    01004     return;
    01005   }
    01006
    01007   ofs << ">> " << alg.name() << endl << *hist << endl;
    01008
    01009 }

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

Definition at line 1029 of file HistorySvc.cpp.

    01029                                                                  {
    01030
    01031   AlgToolHistory *hist = getAlgToolHistory( alg );
    01032
    01033   if (hist == 0) {
    01034     return;
    01035   }
    01036
    01037   ofs << ">> " << alg.name() << endl << *hist << endl;
    01038
    01039 }

std::string HistorySvc::dumpProp | ( | const Property * | prop | ) | const`[private]`

Definition at line 944 of file HistorySvc.cpp.

    00944                                                {
    00945   std::ostringstream ost;
    00946   prop->fillStream(ost);
    00947   return ost.str();
    00948 }

IAlgorithm * HistorySvc::getCurrentIAlg | ( |  | ) | const`[private]`

Definition at line 557 of file HistorySvc.cpp.

    00557                                  {
    00558   if (p_algCtxSvc == 0) {
    00559     m_log << MSG::WARNING << "trying to create DataHistoryObj before "
    00560           << "HistorySvc has been initialized" << endmsg;
    00561     return 0;
    00562
    00563   } else {
    00564     return p_algCtxSvc->currentAlg();
    00565   }
    00566 }

## Friends And Related Function Documentation

friend class SvcFactory< HistorySvc >`[friend]`

Definition at line 104 of file HistorySvc.h.

## Member Data Documentation

bool HistorySvc::m_isInitialized`[private]`

Definition at line 106 of file HistorySvc.h.

bool HistorySvc::m_dump`[private]`

Definition at line 107 of file HistorySvc.h.

bool HistorySvc::m_activate`[private]`

Definition at line 108 of file HistorySvc.h.

IAlgContextSvc* HistorySvc::p_algCtxSvc`[private]`

Definition at line 110 of file HistorySvc.h.

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

Definition at line 112 of file HistorySvc.h.

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

Definition at line 113 of file HistorySvc.h.

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

Definition at line 115 of file HistorySvc.h.

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

Definition at line 116 of file HistorySvc.h.

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

Definition at line 117 of file HistorySvc.h.

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

Definition at line 119 of file HistorySvc.h.

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

Definition at line 120 of file HistorySvc.h.

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

Definition at line 122 of file HistorySvc.h.

JobHistory* HistorySvc::m_jobHistory`[private]`

Definition at line 126 of file HistorySvc.h.

std::string HistorySvc::m_outputFile`[private]`

Definition at line 128 of file HistorySvc.h.

IIncidentSvc* HistorySvc::m_incidentSvc`[private]`

Definition at line 144 of file HistorySvc.h.

MsgStream HistorySvc::m_log`[mutable, private]`

Definition at line 146 of file HistorySvc.h.

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

- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r7/GaudiSvc/src/HistorySvc/HistorySvc.h
- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r7/GaudiSvc/src/HistorySvc/HistorySvc.cpp