DataOnDemandSvc Class Reference

#include <IncidentSvc/DataOnDemandSvc.h>

Inheritance diagram for DataOnDemandSvc:

[legend]

Collaboration diagram for DataOnDemandSvc:

[legend]

List of all members.

Detailed Description

The DataOnDemandSvc listens to incidents typically triggered by the data service of the configurable name "IncidentName".

In the job options handlers can be declared, which allow to configure this service. Such handlers are either:

Node handlers, if objects other than the default object type have to be instantiated. DataOnDemandSvc.Nodes = { "DATA='/Event/Rec' TYPE='DataObject'", "DATA='/Event/Rec/Muon' TYPE='DataObject'" };

Leaf handlers (Algorithms), which get instantiated and executed on demand. DataOnDemandSvc.Algorithms = { "DATA='/Event/Rec/Muon/Digits' TYPE='MuonDigitAlg/MyMuonDigits'" }; If the algorithm name is omitted the class name will be the instance name.

The handlers only get called if the exact path mathes. In the event already the partial path to any handler is missing a leaf handler may be triggered, which includes the partal pathes ( DataOnDemandSvc.UsePreceedingPath = true )

2006-10-15: New options (using map-like semantics:)

    DataOnDemandSvc.AlgMap  +=
   { "Phys/StdLoosePions/Particles" : "PreLoadParticles/StdLoosePions" ,
     "Phys/StdLoosePions/Vertioces" : "PreLoadParticles/StdLoosePions" } ;

    DataOnDemandSvc.NodeMap +=
   { "Phys" : "DataObject" ,
     "MC"   : "DataObject" } ;

New treatment of preceeding paths. for each registered leaf or node the all parent nodes are added into the node-map with default directory type 'DataObject'

The major properties are equipped with handlers (more or less mandatory for interactive work in python)

From now the default prefix ( "/Event/" ) coudl be omitted from any data-item. It will be added automatically.

Author:: M.Frank

Version:: 1.0

Definition at line 89 of file DataOnDemandSvc.h.


Public Types
typedef std::vector< std::string >	Setup
typedef ROOT::Reflex::Type	ClassH
typedef std::map< std::string, Node >	NodeMap
typedef std::map< std::string, Leaf >	AlgMap
Public Member Functions
virtual StatusCode	initialize ()
	Inherited Service overrides: Service initialization.
virtual StatusCode	finalize ()
	Inherited Service overrides: Service finalization.
virtual StatusCode	reinitialize ()
	Inherited Service overrides: Service reinitialization.
virtual void	handle (const Incident &incident)
	IIncidentListener interfaces overrides: incident handling.
	DataOnDemandSvc (const std::string &name, ISvcLocator *svc)
	Standard initializing service constructor.
virtual	~DataOnDemandSvc ()
	Standard destructor.
void	update_1 (Property &p)
void	update_2 (Property &p)
void	update_3 (Property &p)
Protected Member Functions
StatusCode	configureHandler (Leaf &leaf)
	Configure handler for leaf.
StatusCode	execHandler (const std::string &tag, Leaf &leaf)
	Execute leaf handler (algorithm).
StatusCode	execHandler (const std::string &tag, Node &node)
	Execute node handler (simple object creation using seal reflection).
StatusCode	setupNodeHandlers ()
	Initialize node handlers.
StatusCode	setupAlgHandlers ()
	Initialize leaf handlers.
StatusCode	setup ()
	Setup routine (called by (re-) initialize.
StatusCode	update ()
	update the handlers
MsgStream &	stream () const
	get the message stream
void	dump (const MSG::Level level, const bool mode=true) const
	dump the content of DataOnDemand service
Private Types
typedef std::map< std::string, std::string >	Map
Private Attributes
IIncidentSvc *	m_incSvc
	Incident service.
IAlgManager *	m_algMgr
	Algorithm manager.
IDataProviderSvc *	m_dataSvc
	Data provider reference.
std::string	m_trapType
	Trap name.
std::string	m_dataSvcName
	Data service name.
bool	m_partialPath
	Flag to allow for the creation of partial leaves.
bool	m_dump
	flag to force the printout
Setup	m_algMapping
	Mapping to algorithms.
Setup	m_nodeMapping
	Mapping to nodes.
AlgMap	m_algs
	Map of algorithms to handle incidents.
NodeMap	m_nodes
	Map of "empty" objects to be placed as intermediate nodes.
Map	m_algMap
	the major configuration property { 'data' : 'algorithm' }
Map	m_nodeMap
	the major configuration property { 'data' : 'type' }
bool	m_updateRequired
std::string	m_prefix
MsgStream *	m_log
ChronoEntity	m_total
ulonglong	m_statAlg
ulonglong	m_statNode
ulonglong	m_stat
Classes
struct	Leaf
struct	Node
	Helper class of the DataOnDemandSvc. More...
struct	Protection
	Helper class of the DataOnDemandSvc. More...
struct	Timer

Member Typedef Documentation

typedef std::vector<std::string> DataOnDemandSvc::Setup

Definition at line 93 of file DataOnDemandSvc.h.

typedef ROOT::Reflex::Type DataOnDemandSvc::ClassH

Definition at line 94 of file DataOnDemandSvc.h.

typedef std::map<std::string, Node> DataOnDemandSvc::NodeMap

Definition at line 165 of file DataOnDemandSvc.h.

typedef std::map<std::string, Leaf> DataOnDemandSvc::AlgMap

Definition at line 166 of file DataOnDemandSvc.h.

typedef std::map<std::string,std::string> DataOnDemandSvc::Map [private]

Definition at line 262 of file DataOnDemandSvc.h.

Constructor & Destructor Documentation

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

Standard initializing service constructor.

Parameters:

	name	[IN] Service name
	svc	[IN] Pointer to service locator

Returns:: Reference to DataOnDemandSvc object.

Definition at line 38 of file DataOnDemandSvc.cpp.

00039   : base_class(name, svc)
00040   , m_incSvc   ( 0 )
00041   , m_algMgr   ( 0 )
00042   , m_dataSvc  ( 0 )
00043   //
00044   , m_trapType    ( "DataFault")
00045   , m_dataSvcName ( "EventDataSvc" )
00046   , m_partialPath ( true  )
00047   , m_dump        ( false )
00048   //
00049   , m_algMapping  ()
00050   , m_nodeMapping ()
00051   //
00052   , m_algMap   (   )
00053   , m_nodeMap  (   )
00054   //
00055   , m_updateRequired ( true )
00056   , m_prefix         ( "/Event/" )
00057   , m_log      ( 0 )
00058   , m_total    (   )
00059   , m_statAlg  ( 0 )
00060   , m_statNode ( 0 )
00061   , m_stat     ( 0 )
00062 {
00063   // ==========================================================================
00064   declareProperty ( "IncidentName"       , m_trapType    ) ;
00065   declareProperty ( "DataSvc"            , m_dataSvcName ) ;
00066   declareProperty ( "UsePreceedingPath"  , m_partialPath ) ;
00067   declareProperty ( "Dump"               , m_dump        ) ;
00068   //
00069   declareProperty ( "Algorithms"         , m_algMapping  )  ->
00070     declareUpdateHandler ( &DataOnDemandSvc::update_2 , this ) ;
00071   declareProperty ( "Nodes"              , m_nodeMapping ) ->
00072     declareUpdateHandler ( &DataOnDemandSvc::update_3 , this ) ;
00073   //
00074   declareProperty ( "AlgMap"  , m_algMap  ) ->
00075     declareUpdateHandler ( &DataOnDemandSvc::update_1 , this ) ;
00076   declareProperty ( "NodeMap" , m_nodeMap ) ->
00077     declareUpdateHandler ( &DataOnDemandSvc::update_1 , this ) ;
00078   //
00079   declareProperty ( "Prefix"             , m_prefix      ) ;
00080   // ==========================================================================
00081 }

DataOnDemandSvc::~DataOnDemandSvc ( ) [virtual]

Standard destructor.

Definition at line 266 of file DataOnDemandSvc.cpp.

00267 { if ( 0 != m_log      ) { delete m_log      ; m_log      = 0 ; } }

Member Function Documentation

StatusCode DataOnDemandSvc::initialize ( ) [virtual]

Inherited Service overrides: Service initialization.

Reimplemented from Service.

Definition at line 271 of file DataOnDemandSvc.cpp.

00272 {
00273   // initialize the Service Base class
00274   StatusCode sc = Service::initialize();
00275   if ( sc.isFailure() )  { return sc; }
00276   sc = setup();
00277   if ( sc.isFailure() )  { return sc; }
00278   //
00279   if      ( m_dump )                      { dump ( MSG::INFO  ) ; }
00280   else if ( MSG::DEBUG >= outputLevel() ) { dump ( MSG::DEBUG ) ; }
00281   //
00282   return StatusCode::SUCCESS ;
00283 }

StatusCode DataOnDemandSvc::finalize ( void ) [virtual]

Inherited Service overrides: Service finalization.

Reimplemented from Service.

Definition at line 402 of file DataOnDemandSvc.cpp.

00403 {
00404   //
00405   stream ()
00406     << MSG::INFO
00407     << "Handled \"" << m_trapType << "\" incidents: "
00408     << m_statAlg  << "/" << m_statNode << "/" << m_stat << "(Alg/Node/Total)."
00409     << endmsg ;
00410   if ( m_dump || MSG::DEBUG >= outputLevel() )
00411   {
00412     stream ()
00413       << MSG::INFO
00414       << m_total.outputUserTime
00415       ( "Algorithm timing: Mean(+-rms)/Min/Max:%3%(+-%4%)/%6%/%7%[ms] " , System::milliSec )
00416       << m_total.outputUserTime ( "Total:%2%[s]" , System::Sec ) << endmsg ;
00417   }
00418   // dump it!
00419   if      ( m_dump )                      { dump ( MSG::INFO  , false ) ; }
00420   else if ( MSG::DEBUG >= outputLevel() ) { dump ( MSG::DEBUG , false ) ; }
00421   //
00422   if ( m_incSvc )
00423   {
00424     m_incSvc->removeListener(this, m_trapType);
00425     m_incSvc->release();
00426     m_incSvc = 0;
00427   }
00428   if ( 0 != m_algMgr  ) { m_algMgr   -> release () ; m_algMgr  = 0 ; }
00429   if ( 0 != m_dataSvc ) { m_dataSvc  -> release () ; m_dataSvc = 0 ; }
00430   //
00431   return Service::finalize();
00432 }

StatusCode DataOnDemandSvc::reinitialize ( ) [virtual]

Inherited Service overrides: Service reinitialization.

re-initialization of the service

Reimplemented from Service.

Definition at line 436 of file DataOnDemandSvc.cpp.

00437 {
00438   // reinitialize the Service Base class
00439   if ( 0 != m_incSvc )
00440   {
00441     m_incSvc -> removeListener ( this , m_trapType );
00442     m_incSvc -> release ();
00443     m_incSvc = 0;
00444   }
00445   if ( 0 != m_algMgr  ) { m_algMgr   -> release() ; m_algMgr  = 0 ; }
00446   if ( 0 != m_dataSvc ) { m_dataSvc  -> release() ; m_dataSvc = 0 ; }
00447   if ( 0 != m_log     ) { delete m_log ; m_log = 0 ; }
00448   //
00449   StatusCode sc = Service::reinitialize();
00450   if ( sc.isFailure() )  { return sc; }
00451   //
00452   sc = setup() ;
00453   if ( sc.isFailure() )  { return sc; }
00454   //
00455   if ( m_dump ) { dump ( MSG::INFO ) ; }
00456   else if ( MSG::DEBUG >= outputLevel() ) { dump ( MSG::DEBUG  ) ; }
00457   //
00458   return StatusCode::SUCCESS ;
00459 }

void DataOnDemandSvc::handle ( const Incident & incident ) [virtual]

IIncidentListener interfaces overrides: incident handling.

Implements IIncidentListener.

Definition at line 599 of file DataOnDemandSvc.cpp.

00600 {
00601   ++m_stat ;
00602   // proper incident type?
00603   if ( incident.type() != m_trapType ) { return ; }             // RETURN
00604   const DataIncident* inc = dynamic_cast<const DataIncident*>(&incident);
00605   if ( 0 == inc                      ) { return ; }             // RETURN
00606   // update if needed!
00607   if ( m_updateRequired ) { update() ; }
00608   const std::string& tag = inc->tag();
00609   if ( MSG::VERBOSE >= outputLevel() )
00610   {
00611     stream()
00612       << MSG::VERBOSE
00613       << "Incident: [" << incident.type   () << "] "
00614       << " = "         << incident.source ()
00615       << " Location:"  << tag  << endmsg;
00616   }
00617   // ==========================================================================
00618   NodeMap::iterator icl = m_nodes.find ( tag ) ;
00619   if ( icl != m_nodes.end() )
00620   {
00621     StatusCode sc = execHandler ( tag , icl->second ) ;
00622     if ( sc.isSuccess() ) { ++m_statNode ; }
00623     return ;                                                        // RETURN
00624   }
00625   // ==========================================================================
00626   AlgMap::iterator ialg = m_algs.find ( tag ) ;
00627   if ( ialg != m_algs.end() )
00628   {
00629     StatusCode sc = execHandler ( tag , ialg->second ) ;
00630     if ( sc.isSuccess() ) { ++m_statAlg ; }
00631     return ;                                                        // RETURN
00632   }
00633 }

StatusCode DataOnDemandSvc::configureHandler ( Leaf & leaf ) [protected]

Configure handler for leaf.

Parameters:

leaf

[IN] Reference to leaf handler

Returns:: StatusCode indicating success or failure

Definition at line 578 of file DataOnDemandSvc.cpp.

00579 {
00580   StatusCode sc = StatusCode::FAILURE;
00581   if ( 0 == m_algMgr  ) { return sc; }
00582   l.algorithm = m_algMgr->algorithm(l.name, false);
00583   if ( 0 == l.algorithm )
00584   {
00585     sc = m_algMgr->createAlgorithm(l.type, l.name, l.algorithm, true );
00586     if ( sc.isFailure() )
00587     {
00588       stream()
00589         << MSG::ERROR
00590         << "Failed to create algorithm "
00591         << l.type << "('" << l.name<< "')" << endmsg;
00592     }
00593   }
00594   return sc;
00595 }

StatusCode DataOnDemandSvc::execHandler	(	const std::string &	tag,
		Leaf &	leaf
	)			`[protected]`

Execute leaf handler (algorithm).

Parameters:

	tag	[IN] Path to requested leaf
	leaf	[IN] Reference to leaf handler

Returns:: StatusCode indicating success or failure

Definition at line 684 of file DataOnDemandSvc.cpp.

00685 {
00686   //
00687   if ( l.executing ) { return StatusCode::FAILURE ; }             // RETURN
00688   //
00689   if ( 0 == l.algorithm )
00690   {
00691     StatusCode sc = configureHandler ( l ) ;
00692     if ( sc.isFailure() )
00693     {
00694       stream()
00695         << MSG::ERROR
00696         << "Failed to configure handler for: "
00697         << l.name << "[" << l.type << "] " << tag << endmsg;
00698       return sc ;                                                 // RETURN
00699     }
00700   }
00701   //
00702   Timer timer ( m_total ) ;
00703   //
00704   Protection p(l.executing);
00705   StatusCode sc = l.algorithm->sysExecute();
00706   if ( sc.isFailure() )
00707   {
00708     stream() << MSG::ERROR
00709              << "Failed to execute the algorithm:"
00710              << l.algorithm->name() << " for location:" << tag << endmsg;
00711     return sc ;                                                       // RETURN
00712   }
00713   ++l.num ;
00714   //
00715   return StatusCode::SUCCESS ;
00716 }

StatusCode DataOnDemandSvc::execHandler	(	const std::string &	tag,
		Node &	node
	)			`[protected]`

Execute node handler (simple object creation using seal reflection).

Parameters:

	tag	[IN] Path to requested leaf
	node	[IN] Reference to node handler

Returns:: StatusCode indicating success or failure

Definition at line 638 of file DataOnDemandSvc.cpp.

00639 {
00640   if ( n.executing ) { return StatusCode::FAILURE ; }            // RETURN
00641 
00642   // try to recover the handler
00643   if ( !n.clazz  ) { n.clazz = ROOT::Reflex::Type::ByName(n.name) ; }
00644   if ( !n.clazz  )
00645   {
00646     stream()
00647       << MSG::ERROR
00648       << "Failed to get dictionary for class '"
00649       << n.name
00650       << "' for location:" << tag << endmsg;
00651     return StatusCode::FAILURE ;                               // RETURN
00652   }
00653 
00654   ROOT::Reflex::Object obj = n.clazz.Construct();
00655   DataObject* pO = (DataObject*)obj.Address();
00656   if ( !pO )
00657   {
00658     stream()
00659       << MSG::ERROR
00660       << "Failed to create an object of type:"
00661       << n.clazz.Name(ROOT::Reflex::SCOPED) << " for location:" << tag
00662       << endmsg;
00663     return StatusCode::FAILURE  ;                               // RETURN
00664   }
00665   //
00666   Protection p(n.executing);
00667   StatusCode sc = m_dataSvc->registerObject(tag, pO);
00668   if ( sc.isFailure() )
00669   {
00670     stream()
00671       << MSG::ERROR << "Failed to register an object of type:"
00672       << n.clazz.Name(ROOT::Reflex::SCOPED) << " at location:" << tag
00673       << endmsg;
00674     return sc ;                                                  // RETURN
00675   }
00676   ++n.num ;
00677   //
00678   return StatusCode::SUCCESS ;
00679 }

StatusCode DataOnDemandSvc::setupNodeHandlers ( ) [protected]

Initialize node handlers.

Definition at line 497 of file DataOnDemandSvc.cpp.

00498 {
00499   Setup::const_iterator j;
00500   std::string nam, typ, tag;
00501   StatusCode sc = StatusCode::SUCCESS;
00502   // Setup for node leafs, where simply a constructor is called...
00503   for ( j=m_nodeMapping.begin(); j != m_nodeMapping.end(); ++j)
00504   {
00505     Tokenizer tok(true);
00506     tok.analyse(*j, " ", "", "", "=", "'", "'");
00507     for ( Tokenizer::Items::iterator i = tok.items().begin();
00508           i != tok.items().end(); i++ )   {
00509       const std::string& t = (*i).tag();
00510       const std::string& v = (*i).value();
00511       switch( ::toupper(t[0]) )    {
00512       case 'D':
00513         tag = v;
00514         break;
00515       case 'T':
00516         nam = v;
00517         break;
00518       }
00519     }
00520     if ( m_algMap  .end () != m_algMap  .find ( tag ) ||
00521          m_nodeMap .end () != m_nodeMap .find ( tag ) )
00522     {
00523       stream()
00524         << MSG::WARNING
00525         << "The obsolete property 'Nodes' redefines the action for '"
00526         + tag + "' to be '" +nam+"'"
00527         << endmsg ;
00528     }
00529     m_nodeMap[tag] = nam ;
00530   }
00531   //
00532   m_updateRequired = true ;
00533   //
00534   return sc;
00535 }

StatusCode DataOnDemandSvc::setupAlgHandlers ( ) [protected]

Initialize leaf handlers.

Definition at line 539 of file DataOnDemandSvc.cpp.

00540 {
00541   Setup::const_iterator j;
00542   std::string typ, tag;
00543 
00544   for(j=m_algMapping.begin(); j != m_algMapping.end(); ++j)
00545   {
00546     Tokenizer tok(true);
00547     tok.analyse(*j, " ", "", "", "=", "'", "'");
00548     for(Tokenizer::Items::iterator i = tok.items().begin(); i != tok.items().end(); i++ )   {
00549       const std::string& t = (*i).tag();
00550       const std::string& v = (*i).value();
00551       switch( ::toupper(t[0]) )    {
00552       case 'D':
00553         tag = v;
00554         break;
00555       case 'T':
00556         typ = v;
00557         break;
00558       }
00559     }
00560     Gaudi::Utils::TypeNameString item(typ);
00561     if ( m_algMap  .end () != m_algMap  .find ( tag ) ||
00562          m_nodeMap .end () != m_nodeMap .find ( tag ) )
00563     {
00564       stream()
00565         << MSG::WARNING
00566         << "The obsolete property 'Algorithms' redefines the action for '"
00567         + tag + "' to be '" +item.type() +"/"+item.name()+"'"
00568         << endmsg ;
00569     }
00570     m_algMap[tag] = item.type() + "/" + item.name() ;
00571   }
00572   m_updateRequired = true ;
00573   return StatusCode::SUCCESS;
00574 }

StatusCode DataOnDemandSvc::setup ( ) [protected]

Setup routine (called by (re-) initialize.

Definition at line 463 of file DataOnDemandSvc.cpp.

00464 {
00465   m_algMgr = 0;
00466   StatusCode sc =
00467     serviceLocator()->queryInterface(IAlgManager::interfaceID(), pp_cast<void>(&m_algMgr));
00468   if ( sc.isFailure () )
00469   {
00470     stream()
00471       << MSG::ERROR
00472       << "Failed to retrieve the IAlgManager interface." << endmsg;
00473     return sc;
00474   }
00475   sc = service("IncidentSvc", m_incSvc, true);
00476   if ( sc.isFailure () )
00477   {
00478     stream()
00479       << MSG::ERROR << "Failed to retrieve Incident service." << endmsg;
00480     return sc;
00481   }
00482   m_incSvc->addListener(this, m_trapType);
00483   sc = service(m_dataSvcName, m_dataSvc, true);
00484   if ( sc.isFailure () )
00485   {
00486     stream()
00487       << MSG::ERROR
00488       << "Failed to retrieve the data provider interface of "
00489       << m_dataSvcName << endmsg;
00490     return sc;
00491   }
00492   return update() ;
00493 }

void DataOnDemandSvc::update_1 ( Property & p )

Definition at line 85 of file DataOnDemandSvc.cpp.

00086 {
00087   stream() << MSG::VERBOSE << " I am update handler for property " << p << endmsg ;
00088   // force update
00089   m_updateRequired = true ;
00090 }

void DataOnDemandSvc::update_2 ( Property & p )

Definition at line 106 of file DataOnDemandSvc.cpp.

00107 {
00108   stream() << MSG::WARNING
00109            << "The property 'Algorithms' is obsolete, switch to map-like 'AlgMap'  "
00110            << " = { 'data' : 'algorithm' } "
00111            << endmsg ;
00112   // force update
00113   m_updateRequired = true ;
00114 }

void DataOnDemandSvc::update_3 ( Property & p )

Definition at line 94 of file DataOnDemandSvc.cpp.

00095 {
00096   stream() << MSG::WARNING
00097            << "The property 'Nodes'      is obsolete, switch to map-like 'NodeMap' "
00098            << " = { 'data' : 'type'      } "
00099            << endmsg ;
00100   // force update
00101   m_updateRequired = true ;
00102 }

StatusCode DataOnDemandSvc::update ( ) [protected]

update the handlers

convert obsolete "Nodes" into new "NodeMap"

convert obsolete "Algorithms" into new "AlgMap"

add the default prefix

get all directories

setup algorithms

setup nodes

Definition at line 198 of file DataOnDemandSvc.cpp.

00199 {
00200   StatusCode sc = StatusCode::SUCCESS ;
00202   sc = setupNodeHandlers() ; // convert "Nodes"      new "NodeMap"
00203   if ( sc.isFailure() )
00204   {
00205     stream() << MSG::ERROR << "Failed to setup old \"Nodes\""      << endmsg ;
00206     return sc ;
00207   }
00209   sc = setupAlgHandlers()   ; // convert "Algorithms" into "AlgMap"
00210   if ( sc.isFailure() )
00211   {
00212     stream() << MSG::ERROR << "Failed to setup old \"Algorithms\"" << endmsg ;
00213     return sc ;
00214   }
00216   add_prefix ( m_algMap  , m_prefix ) ;
00218   add_prefix ( m_nodeMap , m_prefix ) ;
00220   typedef std::set<std::string> Set ;
00221   Set dirs ;
00222   if ( m_partialPath ){ get_dirs ( m_algMap  , dirs ) ; }
00223   if ( m_partialPath ){ get_dirs ( m_nodeMap , dirs ) ; }
00224   //
00225   Set::iterator _e = dirs.find("/Event") ;
00226   if ( dirs.end() != _e ) { dirs.erase( _e ) ; }
00227   // add all directories as nodes
00228   for ( Set::const_iterator dir = dirs.begin() ; dirs.end() != dir ; ++dir )
00229   {
00230     if ( m_algMap  .end () != m_algMap  .find ( *dir ) ) { continue ; }
00231     if ( m_nodeMap .end () != m_nodeMap .find ( *dir ) ) { continue ; }
00232     m_nodeMap [*dir] = "DataObject" ;
00233   }
00234   //
00235   m_algs  .clear  () ;
00236   m_nodes .clear  () ;
00237   //
00239   for ( Map::const_iterator ialg = m_algMap.begin() ;
00240         m_algMap.end() != ialg ; ++ialg )
00241   {
00242     Gaudi::Utils::TypeNameString alg ( ialg->second ) ;
00243     m_algs[ialg->first] =  Leaf( alg.type() , alg.name() ) ;
00244   }
00246   for ( Map::const_iterator inode = m_nodeMap.begin() ;
00247         m_nodeMap.end() != inode ; ++inode )
00248   {
00249     ClassH cl = ROOT::Reflex::Type::ByName( inode->second ) ;
00250     if ( !cl )
00251     {
00252       stream() << MSG::WARNING
00253                << "Failed to access dictionary class for "
00254                << inode->first << " of type:" << inode->second << endmsg;
00255     }
00256     m_nodes[inode->first] = Node ( cl , false , inode->second ) ;
00257   }
00259   m_updateRequired = false ;
00260   //
00261   return StatusCode::SUCCESS ;
00262 }

MsgStream& DataOnDemandSvc::stream ( ) const [inline, protected]

get the message stream

Definition at line 226 of file DataOnDemandSvc.h.

00227   {
00228     if ( 0 == m_log ) { m_log = new MsgStream( msgSvc() , name() ) ; }
00229     return *m_log;
00230   }

void DataOnDemandSvc::dump	(	const MSG::Level	level,
		const bool	mode = `true`
	)			const `[protected]`

dump the content of DataOnDemand service

Parameters:

	level	the printout level
	mode	the printout mode

Definition at line 291 of file DataOnDemandSvc.cpp.

00293 {
00294   if ( m_algs.empty()  &&  m_nodes.empty() ) { return ; }
00295 
00296   typedef std::pair<std::string,std::string> Pair ;
00297   typedef std::map<std::string,Pair>         PMap ;
00298 
00299   PMap _m ;
00300   for ( AlgMap::const_iterator alg = m_algs.begin() ;
00301         m_algs.end() != alg ; ++alg )
00302   {
00303     PMap::const_iterator check = _m.find(alg->first) ;
00304     if ( _m.end() != check )
00305     {
00306       stream()
00307         << MSG::WARNING
00308         << " The data item is activated for '"
00309         << check->first << "' as '" << check->second.first << "'" << endmsg ;
00310     }
00311     const Leaf& l = alg->second ;
00312     std::string nam = ( l.name == l.type ? l.type  : (l.type+"/"+l.name) ) ;
00313     //
00314     if ( !mode && 0 == l.num ) { continue ; }
00315     //
00316     std::string val ;
00317     if ( mode ) { val = ( 0 == l.algorithm ) ? "F" : "T" ; }
00318     else { val = boost::lexical_cast<std::string>( l.num ) ; }
00319     //
00320     _m[ no_prefix ( alg->first , m_prefix ) ] = std::make_pair ( nam , val ) ;
00321   }
00322   // nodes:
00323   for ( NodeMap::const_iterator node = m_nodes.begin() ;
00324         m_nodes.end() != node ; ++node )
00325   {
00326     PMap::const_iterator check = _m.find(node->first) ;
00327     if ( _m.end() != check )
00328     {
00329       stream()
00330         << MSG::WARNING
00331         << " The data item is already activated for '"
00332         << check->first << "' as '" << check->second.first << "'" << endmsg ;
00333     }
00334     const Node& n = node->second ;
00335     std::string nam = "'" + n.name + "'"  ;
00336     //
00337     std::string val ;
00338 
00339     if ( !mode && 0 == n.num ) { continue ; }
00340 
00341     if ( mode ) { val = ( 0 == n.clazz ) ? "F" : "T" ; }
00342     else { val = boost::lexical_cast<std::string>( n.num ) ; }
00343     //
00344     _m[ no_prefix ( node->first , m_prefix ) ] = std::make_pair ( nam , val ) ;
00345   }
00346   //
00347   if ( _m.empty() ) { return ; }
00348 
00349   // find the correct formats
00350   size_t n1 = 0 ;
00351   size_t n2 = 0 ;
00352   size_t n3 = 0 ;
00353   for  ( PMap::const_iterator it = _m.begin() ; _m.end() != it ; ++it )
00354   {
00355     n1 = std::max ( n1 , it->first.size()         ) ;
00356     n2 = std::max ( n2 , it->second.first.size()  ) ;
00357     n3 = std::max ( n3 , it->second.second.size() ) ;
00358   }
00359   if ( 10 > n1 ) { n1 = 10 ; }
00360   if ( 10 > n2 ) { n2 = 10 ; }
00361   if ( 60 < n1 ) { n1 = 60 ; }
00362   if ( 60 < n2 ) { n2 = 60 ; }
00363   //
00364 
00365   const std::string _f = " | %%1$-%1%.%1%s | %%2$-%2%.%2%s | %%3$%3%.%3%s |" ;
00366   boost::format _ff ( _f ) ;
00367   _ff % n1 % n2 % n3 ;
00368 
00369   const std::string _format  = _ff.str() ;
00370 
00371   MsgStream& msg = stream() << level ;
00372 
00373   if ( mode ) { msg << "Data-On-Demand Actions enabled for:"       ; }
00374   else        { msg << "Data-On-Demand Actions has been used for:" ; }
00375 
00376   boost::format fmt1( _format)  ;
00377   fmt1 % "Address" % "Creator" % ( mode ? "S" : "#" ) ;
00378   //
00379   const std::string header = fmt1.str() ;
00380   std::string line = std::string( header.size() , '-' ) ;
00381   line[0] = ' ' ;
00382 
00383   msg << std::endl << line
00384       << std::endl << header
00385       << std::endl << line ;
00386 
00387   // make the actual printout:
00388   for ( PMap::const_iterator item = _m.begin() ;
00389         _m.end() != item ; ++item )
00390   {
00391     boost::format fmt( _format)  ;
00392     msg << std::endl <<
00393       ( fmt % item->first % item->second.first % item->second.second ) ;
00394   }
00395 
00396   msg << std::endl << line << endmsg ;
00397 
00398 }

Member Data Documentation

IIncidentSvc* DataOnDemandSvc::m_incSvc [private]

Incident service.

Definition at line 240 of file DataOnDemandSvc.h.

IAlgManager* DataOnDemandSvc::m_algMgr [private]

Algorithm manager.

Definition at line 242 of file DataOnDemandSvc.h.

IDataProviderSvc* DataOnDemandSvc::m_dataSvc [private]

Data provider reference.

Definition at line 244 of file DataOnDemandSvc.h.

std::string DataOnDemandSvc::m_trapType [private]

Trap name.

Definition at line 246 of file DataOnDemandSvc.h.

std::string DataOnDemandSvc::m_dataSvcName [private]

Data service name.

Definition at line 248 of file DataOnDemandSvc.h.

bool DataOnDemandSvc::m_partialPath [private]

Flag to allow for the creation of partial leaves.

Definition at line 250 of file DataOnDemandSvc.h.

bool DataOnDemandSvc::m_dump [private]

flag to force the printout

Definition at line 252 of file DataOnDemandSvc.h.

Setup DataOnDemandSvc::m_algMapping [private]

Mapping to algorithms.

Definition at line 254 of file DataOnDemandSvc.h.

Setup DataOnDemandSvc::m_nodeMapping [private]

Mapping to nodes.

Definition at line 256 of file DataOnDemandSvc.h.

AlgMap DataOnDemandSvc::m_algs [private]

Map of algorithms to handle incidents.

Definition at line 258 of file DataOnDemandSvc.h.

NodeMap DataOnDemandSvc::m_nodes [private]

Map of "empty" objects to be placed as intermediate nodes.

Definition at line 260 of file DataOnDemandSvc.h.

Map DataOnDemandSvc::m_algMap [private]

the major configuration property { 'data' : 'algorithm' }

Definition at line 264 of file DataOnDemandSvc.h.

Map DataOnDemandSvc::m_nodeMap [private]

the major configuration property { 'data' : 'type' }

Definition at line 266 of file DataOnDemandSvc.h.

bool DataOnDemandSvc::m_updateRequired [private]

Definition at line 267 of file DataOnDemandSvc.h.

std::string DataOnDemandSvc::m_prefix [private]

Definition at line 268 of file DataOnDemandSvc.h.

MsgStream* DataOnDemandSvc::m_log [mutable, private]

Definition at line 269 of file DataOnDemandSvc.h.

ChronoEntity DataOnDemandSvc::m_total [private]

Definition at line 271 of file DataOnDemandSvc.h.

ulonglong DataOnDemandSvc::m_statAlg [private]

Definition at line 272 of file DataOnDemandSvc.h.

ulonglong DataOnDemandSvc::m_statNode [private]

Definition at line 273 of file DataOnDemandSvc.h.

ulonglong DataOnDemandSvc::m_stat [private]

Definition at line 274 of file DataOnDemandSvc.h.

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

/afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r6/GaudiSvc/src/IncidentSvc/DataOnDemandSvc.h
/afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r6/GaudiSvc/src/IncidentSvc/DataOnDemandSvc.cpp

Gaudi Framework, version v21r6

DataOnDemandSvc Class Reference

Detailed Description

Public Types

Public Member Functions

Protected Member Functions

Private Types

Private Attributes

Classes

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation