| The Gaudi Framework v30r0 (c919700c)

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

OutputStream.cpp
Go to the documentation of this file.
1 // Framework include files
2 #include "GaudiKernel/IAlgManager.h"
3 #include "GaudiKernel/IConversionSvc.h"
4 #include "GaudiKernel/IDataManagerSvc.h"
5 #include "GaudiKernel/IDataProviderSvc.h"
6 #include "GaudiKernel/IIncidentSvc.h"
7 #include "GaudiKernel/IOpaqueAddress.h"
8 #include "GaudiKernel/IPersistencySvc.h"
9 #include "GaudiKernel/IRegistry.h"
10 #include "GaudiKernel/ISvcLocator.h"
11 #include "GaudiKernel/Incident.h"
12
13 #include "GaudiKernel/AttribStringParser.h"
14 #include "GaudiKernel/DataObject.h"
15 #include "GaudiKernel/DataStoreItem.h"
16 #include "GaudiKernel/MsgStream.h"
17 #include "GaudiKernel/strcasecmp.h"
18
19 #include "OutputStream.h"
20 #include "OutputStreamAgent.h"
21
22 #include <set>
23
24 // Define the algorithm factory for the standard output data writer
25 DECLARE_COMPONENT( OutputStream )
26
27 #define ON_DEBUG if ( msgLevel( MSG::DEBUG ) )
28
29 // Standard Constructor
30 OutputStream::OutputStream( const std::string& name, ISvcLocator* pSvcLocator )
31 : Algorithm( name, pSvcLocator ), m_agent{new OutputStreamAgent( this )}
32 {
33 // Associate action handlers with the AcceptAlgs, RequireAlgs and VetoAlgs.
34 m_acceptNames.declareUpdateHandler( &OutputStream::acceptAlgsHandler, this );
35 m_requireNames.declareUpdateHandler( &OutputStream::requireAlgsHandler, this );
36 m_vetoNames.declareUpdateHandler( &OutputStream::vetoAlgsHandler, this );
37 }
38
39 // initialize data writer
40 StatusCode OutputStream::initialize()
41 {
42
43 // Reset the number of events written
44 m_events = 0;
45 // Get access to the DataManagerSvc
46 m_pDataManager = serviceLocator()->service( m_storeName );
47 if ( !m_pDataManager ) {
48 fatal() << "Unable to locate IDataManagerSvc interface" << endmsg;
49 return StatusCode::FAILURE;
50 }
51 // Get access to the IncidentService
52 m_incidentSvc = serviceLocator()->service( "IncidentSvc" );
53 if ( !m_incidentSvc ) {
54 warning() << "Error retrieving IncidentSvc." << endmsg;
55 return StatusCode::FAILURE;
56 }
57 // Get access to the assigned data service
58 m_pDataProvider = serviceLocator()->service( m_storeName );
59 if ( !m_pDataProvider ) {
60 fatal() << "Unable to locate IDataProviderSvc interface of " << m_storeName << endmsg;
61 return StatusCode::FAILURE;
62 }
63 if ( hasInput() ) {
64 StatusCode status = connectConversionSvc();
65 if ( !status.isSuccess() ) {
66 fatal() << "Unable to connect to conversion service." << endmsg;
67 if ( m_outputName != "" && m_fireIncidents )
68 m_incidentSvc->fireIncident( Incident( m_outputName, IncidentType::FailOutputFile ) );
69 return status;
70 }
71 }
72
73 // Clear the list with optional items
74 clearItems( m_optItemList );
75 // Clear the item list
76 clearItems( m_itemList );
77
78 // Take the new item list from the properties.
79 ON_DEBUG debug() << "ItemList : " << m_itemNames.value() << endmsg;
80 for ( const auto& i : m_itemNames ) addItem( m_itemList, i );
81
82 // Take the new item list from the properties.
83 ON_DEBUG debug() << "OptItemList : " << m_optItemNames.value() << endmsg;
84 for ( const auto& i : m_optItemNames ) addItem( m_optItemList, i );
85
86 // prepare the algorithm selected dependent locations
87 ON_DEBUG debug() << "AlgDependentItemList : " << m_algDependentItemList.value() << endmsg;
88 for ( const auto& a : m_algDependentItemList ) {
89 // Get the algorithm pointer
90 Algorithm* theAlgorithm = decodeAlgorithm( a.first );
91 if ( theAlgorithm ) {
92 // Get the item list for this alg
93 auto& items = m_algDependentItems[theAlgorithm];
94 // Clear the list for this alg
95 clearItems( items );
96 // fill the list again
97 for ( const auto& i : a.second ) addItem( items, i );
98 }
99 }
100
101 // Take the item list to the data service preload list.
102 if ( m_doPreLoad ) {
103 for ( auto& j : m_itemList ) m_pDataProvider->addPreLoadItem( *j ).ignore();
104 // Not working: bad reference counting! pdataSvc->release();
105 }
106
107 if ( m_doPreLoadOpt ) {
108 for ( auto& j : m_optItemList ) m_pDataProvider->addPreLoadItem( *j ).ignore();
109 }
110 info() << "Data source: " << m_storeName.value() << " output: " << m_output.value() << endmsg;
111
112 // Decode the accept, required and veto Algorithms. The logic is the following:
113 // a. The event is accepted if all lists are empty.
114 // b. The event is provisionally accepted if any Algorithm in the accept list
115 // has been executed and has indicated that its filter is passed. This
116 // provisional acceptance can be overridden by the other lists.
117 // c. The event is rejected unless all Algorithms in the required list have
118 // been executed and have indicated that their filter passed.
119 // d. The event is rejected if any Algorithm in the veto list has been
120 // executed and has indicated that its filter has passed.
121 decodeAcceptAlgs().ignore();
122 decodeRequireAlgs().ignore();
123 decodeVetoAlgs().ignore();
124 return StatusCode::SUCCESS;
125 }
126
127 // terminate data writer
128 StatusCode OutputStream::finalize()
129 {
130 info() << "Events output: " << m_events << endmsg;
131 if ( m_fireIncidents ) m_incidentSvc->fireIncident( Incident( m_outputName, IncidentType::EndOutputFile ) );
132 m_incidentSvc.reset();
133 m_pDataProvider.reset();
134 m_pDataManager.reset();
135 m_pConversionSvc.reset();
136 clearItems( m_optItemList );
137 clearItems( m_itemList );
138 return StatusCode::SUCCESS;
139 }
140
141 // Work entry point
142 StatusCode OutputStream::execute()
143 {
144 // Clear any previously existing item list
145 clearSelection();
146 // Test whether this event should be output
147 if ( isEventAccepted() ) {
148 const StatusCode sc = writeObjects();
149 clearSelection();
150 ++m_events;
151 if ( sc.isSuccess() && m_fireIncidents ) {
152 m_incidentSvc->fireIncident( Incident( m_outputName, IncidentType::WroteToOutputFile ) );
153 } else if ( m_fireIncidents ) {
154 m_incidentSvc->fireIncident( Incident( m_outputName, IncidentType::FailOutputFile ) );
155 }
156 return sc;
157 }
158 return StatusCode::SUCCESS;
159 }
160
161 // Select the different objects and write them to file
162 StatusCode OutputStream::writeObjects()
163 {
164 // Connect the output file to the service
165 StatusCode status = collectObjects();
166 if ( status.isSuccess() ) {
167 IDataSelector* sel = selectedObjects();
168 if ( sel->begin() != sel->end() ) {
169 status = m_pConversionSvc->connectOutput( m_outputName, m_outputType );
170 if ( status.isSuccess() ) {
171 // Now pass the collection to the persistency service
172 IOpaqueAddress* pAddress = nullptr;
173 for ( auto& j : *sel ) {
174 try {
175 const StatusCode iret = m_pConversionSvc->createRep( j, pAddress );
176 if ( !iret.isSuccess() ) {
177 status = iret;
178 continue;
179 }
180 IRegistry* pReg = j->registry();
181 pReg->setAddress( pAddress );
182 } catch ( const std::exception& excpt ) {
183 const std::string loc = ( j->registry() ? j->registry()->identifier() : "UnRegistered" );
184 fatal() << "std::exception during createRep for '" << loc << "' " << System::typeinfoName( typeid( *j ) )
185 << endmsg;
186 fatal() << excpt.what() << endmsg;
187 throw;
188 }
189 }
190 for ( auto& j : *sel ) {
191 try {
192 IRegistry* pReg = j->registry();
193 const StatusCode iret = m_pConversionSvc->fillRepRefs( pReg->address(), j );
194 if ( !iret.isSuccess() ) status = iret;
195 } catch ( const std::exception& excpt ) {
196 const std::string loc = ( j->registry() ? j->registry()->identifier() : "UnRegistered" );
197 fatal() << "std::exception during fillRepRefs for '" << loc << "'" << System::typeinfoName( typeid( *j ) )
198 << endmsg;
199 fatal() << excpt.what() << endmsg;
200 throw;
201 }
202 }
203 // Commit the data if there was no error; otherwise possibly discard
204 if ( status.isSuccess() ) {
205 status = m_pConversionSvc->commitOutput( m_outputName, true );
206 } else {
207 m_pConversionSvc->commitOutput( m_outputName, false ).ignore();
208 }
209 }
210 }
211 }
212 return status;
213 }
214
215 // Place holder to create configurable data store agent
216 bool OutputStream::collect( IRegistry* dir, int level )
217 {
218 if ( level < m_currentItem->depth() ) {
219 if ( dir->object() ) {
220 /*
221 std::cout << "Analysing ("
222 << dir->name()
223 << ") Object:"
224 << ((dir->object()==0) ? "UNLOADED" : "LOADED")
225 << std::endl;
226 */
227 m_objects.push_back( dir->object() );
228 return true;
229 }
230 }
231 return false;
232 }
233
235 StatusCode OutputStream::collectObjects()
236 {
237 StatusCode status = StatusCode::SUCCESS;
238
239 // Traverse the tree and collect the requested objects
240 for ( auto& i : m_itemList ) {
241 DataObject* obj = nullptr;
242 m_currentItem = i;
243 StatusCode iret = m_pDataProvider->retrieveObject( m_currentItem->path(), obj );
244 if ( iret.isSuccess() ) {
245 iret = m_pDataManager->traverseSubTree( obj, m_agent.get() );
246 if ( !iret.isSuccess() ) status = iret;
247 } else {
248 error() << "Cannot write mandatory object(s) (Not found) " << m_currentItem->path() << endmsg;
249 status = iret;
250 }
251 }
252
253 // Traverse the tree and collect the requested objects (tolerate missing items here)
254 for ( auto& i : m_optItemList ) {
255 DataObject* obj = nullptr;
256 m_currentItem = i;
257 StatusCode iret = m_pDataProvider->retrieveObject( m_currentItem->path(), obj );
258 if ( iret.isSuccess() ) {
259 iret = m_pDataManager->traverseSubTree( obj, m_agent.get() );
260 }
261 if ( !iret.isSuccess() ) {
262 ON_DEBUG
263 debug() << "Ignore request to write non-mandatory object(s) " << m_currentItem->path() << endmsg;
264 }
265 }
266
267 // Collect objects dependent on particular algorithms
268 for ( const auto& iAlgItems : m_algDependentItems ) {
269 Algorithm* alg = iAlgItems.first;
270 const Items& items = iAlgItems.second;
271 if ( alg->isExecuted() && alg->filterPassed() ) {
272 ON_DEBUG
273 debug() << "Algorithm '" << alg->name() << "' fired. Adding " << items << endmsg;
274 for ( const auto& i : items ) {
275 DataObject* obj = nullptr;
276 m_currentItem = i;
277 StatusCode iret = m_pDataProvider->retrieveObject( m_currentItem->path(), obj );
278 if ( iret.isSuccess() ) {
279 iret = m_pDataManager->traverseSubTree( obj, m_agent.get() );
280 if ( !iret.isSuccess() ) status = iret;
281 } else {
282 error() << "Cannot write mandatory (algorithm dependent) object(s) (Not found) " << m_currentItem->path()
283 << endmsg;
284 status = iret;
285 }
286 }
287 }
288 }
289
290 if ( status.isSuccess() ) {
291 // Remove duplicates from the list of objects, preserving the order in the list
292 std::set<DataObject*> unique;
293 std::vector<DataObject*> tmp; // temporary vector with the reduced list
294 tmp.reserve( m_objects.size() );
295 for ( auto& o : m_objects ) {
296 if ( !unique.count( o ) ) {
297 // if the pointer is not in the set, add it to both the set and the temporary vector
298 unique.insert( o );
299 tmp.push_back( o );
300 }
301 }
302 m_objects.swap( tmp ); // swap the data of the two vectors
303 }
304
305 return status;
306 }
307
308 // Clear collected object list
309 void OutputStream::clearSelection() { m_objects.clear(); }
310
311 // Remove all items from the output streamer list;
312 void OutputStream::clearItems( Items& itms )
313 {
314 for ( auto& i : itms ) delete i;
315 itms.clear();
316 }
317
318 // Find single item identified by its path (exact match)
319 DataStoreItem* OutputStream::findItem( const std::string& path )
320 {
321 auto matchPath = [&]( const DataStoreItem* i ) { return i->path() == path; };
322 auto i = std::find_if( m_itemList.begin(), m_itemList.end(), matchPath );
323 if ( i == m_itemList.end() ) {
324 i = std::find_if( m_optItemList.begin(), m_optItemList.end(), matchPath );
325 if ( i == m_optItemList.end() ) return nullptr;
326 }
327 return *i;
328 }
329
330 // Add item to output streamer list
331 void OutputStream::addItem( Items& itms, const std::string& descriptor )
332 {
333 int level = 0;
334 auto sep = descriptor.rfind( "#" );
335 std::string obj_path = descriptor.substr( 0, sep );
336 if ( sep != std::string::npos ) {
337 std::string slevel = descriptor.substr( sep + 1 );
338 level = ( slevel == "*" ) ? 9999999 : std::stoi( slevel );
339 }
340 if ( m_verifyItems ) {
341 size_t idx = obj_path.find( "/", 1 );
342 while ( idx != std::string::npos ) {
343 std::string sub_item = obj_path.substr( 0, idx );
344 if ( !findItem( sub_item ) ) addItem( itms, sub_item + "#1" );
345 idx = obj_path.find( "/", idx + 1 );
346 }
347 }
348 itms.push_back( new DataStoreItem( obj_path, level ) );
349 const auto& item = itms.back();
350 ON_DEBUG
351 debug() << "Adding OutputStream item " << item->path() << " with " << item->depth() << " level(s)." << endmsg;
352 }
353
354 // Connect to proper conversion service
355 StatusCode OutputStream::connectConversionSvc()
356 {
357 StatusCode status = StatusCode( StatusCode::FAILURE, true );
358 // Get output file from input
359 std::string dbType, svc, shr;
360 for ( auto attrib : Gaudi::Utils::AttribStringParser( m_output ) ) {
361 const std::string& tag = attrib.tag;
362 const std::string& val = attrib.value;
363 switch (::toupper( tag[0] ) ) {
364 case 'D':
365 m_outputName = val;
366 break;
367 case 'T':
368 dbType = val;
369 break;
370 case 'S':
371 switch (::toupper( tag[1] ) ) {
372 case 'V':
373 svc = val;
374 break;
375 case 'H':
376 shr = "YES";
377 break;
378 }
379 break;
380 case 'O': // OPT='<NEW<CREATE,WRITE,RECREATE>, UPDATE>'
381 switch (::toupper( val[0] ) ) {
382 case 'R':
383 if (::strncasecmp( val.c_str(), "RECREATE", 3 ) == 0 )
384 m_outputType = "RECREATE";
385 else if (::strncasecmp( val.c_str(), "READ", 3 ) == 0 )
386 m_outputType = "READ";
387 break;
388 case 'C':
389 case 'N':
390 case 'W':
391 m_outputType = "NEW";
392 break;
393 case 'U':
394 m_outputType = "UPDATE";
395 break;
396 default:
397 m_outputType = "???";
398 break;
399 }
400 break;
401 default:
402 break;
403 }
404 }
405 if ( !shr.empty() ) m_outputType += "|SHARED";
406 // Get access to the default Persistency service
407 // The default service is the same for input as for output.
408 // If this is not desired, then a specialized OutputStream must overwrite
409 // this value.
410 if ( !dbType.empty() || !svc.empty() ) {
411 std::string typ = !dbType.empty() ? dbType : svc;
412 auto ipers = serviceLocator()->service<IPersistencySvc>( m_persName );
413 if ( !ipers ) {
414 fatal() << "Unable to locate IPersistencySvc interface of " << m_persName << endmsg;
415 return StatusCode::FAILURE;
416 }
417 IConversionSvc* cnvSvc = nullptr;
418 status = ipers->getService( typ, cnvSvc );
419 if ( !status.isSuccess() ) {
420 fatal() << "Unable to locate IConversionSvc interface of database type " << typ << endmsg;
421 return status;
422 }
423 // Increase reference count and keep service.
424 m_pConversionSvc = cnvSvc;
425 } else {
426 fatal() << "Unable to locate IConversionSvc interface (Unknown technology) " << endmsg
427 << "You either have to specify a technology name or a service name!" << endmsg
428 << "Please correct the job option \"" << name() << ".Output\" !" << endmsg;
429 return StatusCode::FAILURE;
430 }
431 return StatusCode::SUCCESS;
432 }
433
434 StatusCode OutputStream::decodeAcceptAlgs()
435 {
436 ON_DEBUG
437 debug() << "AcceptAlgs : " << m_acceptNames.value() << endmsg;
438 return decodeAlgorithms( m_acceptNames, m_acceptAlgs );
439 }
440
441 void OutputStream::acceptAlgsHandler( Gaudi::Details::PropertyBase& /* theProp */ )
442 {
443 StatusCode sc = decodeAlgorithms( m_acceptNames, m_acceptAlgs );
444 if ( sc.isFailure() ) {
445 throw GaudiException( "Failure in OutputStream::decodeAlgorithms", "OutputStream::acceptAlgsHandler", sc );
446 }
447 }
448
449 StatusCode OutputStream::decodeRequireAlgs()
450 {
451 ON_DEBUG
452 debug() << "RequireAlgs : " << m_requireNames.value() << endmsg;
453 return decodeAlgorithms( m_requireNames, m_requireAlgs );
454 }
455
456 void OutputStream::requireAlgsHandler( Gaudi::Details::PropertyBase& /* theProp */ )
457 {
458 StatusCode sc = decodeAlgorithms( m_requireNames, m_requireAlgs );
459 if ( sc.isFailure() ) {
460 throw GaudiException( "Failure in OutputStream::decodeAlgorithms", "OutputStream::requireAlgsHandler", sc );
461 }
462 }
463
464 StatusCode OutputStream::decodeVetoAlgs()
465 {
466 ON_DEBUG
467 debug() << "VetoAlgs : " << m_vetoNames.value() << endmsg;
468 return decodeAlgorithms( m_vetoNames, m_vetoAlgs );
469 }
470
471 void OutputStream::vetoAlgsHandler( Gaudi::Details::PropertyBase& /* theProp */ )
472 {
473 StatusCode sc = decodeAlgorithms( m_vetoNames, m_vetoAlgs );
474 if ( sc.isFailure() ) {
475 throw GaudiException( "Failure in OutputStream::decodeAlgorithms", "OutputStream::vetoAlgsHandler", sc );
476 }
477 }
478
479 Algorithm* OutputStream::decodeAlgorithm( const std::string& theName )
480 {
481 Algorithm* theAlgorithm = nullptr;
482
483 auto theAlgMgr = serviceLocator()->as<IAlgManager>();
484 if ( theAlgMgr ) {
485 // Check whether the supplied name corresponds to an existing
486 // Algorithm object.
487 SmartIF<IAlgorithm>& theIAlg = theAlgMgr->algorithm( theName );
488 if ( theIAlg ) {
489 try {
490 theAlgorithm = dynamic_cast<Algorithm*>( theIAlg.get() );
491 } catch ( ... ) {
492 // do nothing
493 }
494 }
495 } else {
496 fatal() << "Can't locate ApplicationMgr!!!" << endmsg;
497 }
498
499 if ( !theAlgorithm ) {
500 warning() << "Failed to decode Algorithm name " << theName << endmsg;
501 }
502
503 return theAlgorithm;
504 }
505
506 StatusCode OutputStream::decodeAlgorithms( Gaudi::Property<std::vector<std::string>>& theNames,
507 std::vector<Algorithm*>& theAlgs )
508 {
509 // Reset the list of Algorithms
510 theAlgs.clear();
511
512 StatusCode result = StatusCode::SUCCESS;
513
514 // Build the list of Algorithms from the names list
515 for ( const auto& it : theNames.value() ) {
516
517 Algorithm* theAlgorithm = decodeAlgorithm( it );
518 if ( theAlgorithm ) {
519 // Check that the specified algorithm doesn't already exist in the list
520 if ( std::find( std::begin( theAlgs ), std::end( theAlgs ), theAlgorithm ) == std::end( theAlgs ) ) {
521 theAlgorithm->addRef();
522 theAlgs.push_back( theAlgorithm );
523 }
524 } else {
525 info() << it << " doesn't exist - ignored" << endmsg;
526 }
527 }
528 result = StatusCode::SUCCESS;
529
530 return result;
531 }
532
533 bool OutputStream::isEventAccepted() const
534 {
535 auto passed = []( const Algorithm* alg ) { return alg->isExecuted() && alg->filterPassed(); };
536
537 // Loop over all Algorithms in the accept list to see
538 // whether any have been executed and have their filter
539 // passed flag set. Any match causes the event to be
540 // provisionally accepted.
541 bool result = m_acceptAlgs.empty() || std::any_of( std::begin( m_acceptAlgs ), std::end( m_acceptAlgs ), passed );
542
543 // Loop over all Algorithms in the required list to see
544 // whether all have been executed and have their filter
545 // passed flag set. Any mismatch causes the event to be
546 // rejected.
547 if ( result && !m_requireAlgs.empty() ) {
548 result = std::all_of( std::begin( m_requireAlgs ), std::end( m_requireAlgs ), passed );
549 }
550
551 // Loop over all Algorithms in the veto list to see
552 // whether any have been executed and have their filter
553 // passed flag set. Any match causes the event to be
554 // rejected.
555 if ( result && !m_vetoAlgs.empty() ) {
556 result = std::none_of( std::begin( m_vetoAlgs ), std::end( m_vetoAlgs ), passed );
557 }
558 return result;
559 }
560
561 bool OutputStream::hasInput() const
562 {
563 return !( m_itemNames.empty() && m_optItemNames.empty() && m_algDependentItemList.empty() );
564 }
OutputStream::m_acceptNames
Gaudi::Property< std::vector< std::string > > m_acceptNames
Definition: OutputStream.h:57
Gaudi::Utils::AttribStringParser
Parse attribute strings allowing iteration over the various attributes.
Definition: AttribStringParser.h:32
OutputStream::isEventAccepted
bool isEventAccepted() const
Test whether this event should be output.
Definition: OutputStream.cpp:533
StatusCode::SUCCESS
Definition: StatusCode.h:29
OutputStream::clearItems
void clearItems(Items &itms)
Clear item list.
Definition: OutputStream.cpp:312
OutputStream::hasInput
virtual bool hasInput() const
Tell if the instance has been configured with input items or not.
Definition: OutputStream.cpp:561
SmartIF< IAlgorithm >
std::string::empty
T empty(T...args)
OutputStream::m_vetoNames
Gaudi::Property< std::vector< std::string > > m_vetoNames
Definition: OutputStream.h:61
GaudiException
Define general base for Gaudi exception.
Definition: GaudiException.h:22
OutputStream::decodeRequireAlgs
StatusCode decodeRequireAlgs()
Decode list of Algorithms that this stream requires.
Definition: OutputStream.cpp:449
ISvcLocator
The ISvcLocator is the interface implemented by the Service Factory in the Application Manager to loc...
Definition: ISvcLocator.h:25
OutputStream::m_objects
IDataSelector m_objects
Collection of objects being selected.
Definition: OutputStream.h:93
OutputStream::finalize
StatusCode finalize() override
Terminate OutputStream.
Definition: OutputStream.cpp:128
Algorithm::name
const std::string & name() const override
The identifying name of the algorithm object.
Definition: Algorithm.cpp:737
GaudiPython.HistoUtils.path
path
Definition: HistoUtils.py:895
gaudiComponentHelp.name
name
Definition: gaudiComponentHelp.py:32
IConversionSvc
Definition: IConversionSvc.h:37
OutputStream::m_events
int m_events
Number of events written to this output stream.
Definition: OutputStream.h:95
Gaudi::Property
Implementation of property with value of concrete type.
Definition: Property.h:319
Algorithm::isExecuted
bool isExecuted() const override
Has this algorithm been executed since the last reset?
Definition: Algorithm.cpp:747
MsgStream.h
CommonMessagingBase::info
MsgStream & info() const
shortcut for the method msgStream(MSG::INFO)
Definition: CommonMessaging.h:112
IDataProviderSvc::addPreLoadItem
virtual StatusCode addPreLoadItem(const DataStoreItem &item)=0
Add an item to the preload list.
OutputStream::m_outputType
std::string m_outputType
Output type: NEW(NEW,CREATE,WRITE,RECREATE), UPDATE)
Definition: OutputStream.h:75
System::typeinfoName
GAUDI_API const std::string typeinfoName(const std::type_info &)
Get platform independent information about the class type.
Definition: System.cpp:336
OutputStream::m_verifyItems
Gaudi::Property< bool > m_verifyItems
Definition: OutputStream.h:63
OutputStream::m_currentItem
DataStoreItem * m_currentItem
Keep track of the current item.
Definition: OutputStream.h:85
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:50
OutputStream::m_output
Gaudi::Property< std::string > m_output
Definition: OutputStream.h:51
std::string::rfind
T rfind(T...args)
OutputStream::m_outputName
Gaudi::Property< std::string > m_outputName
Definition: OutputStream.h:52
IOTest.sel
sel
Definition: IOTest.py:95
IAlgManager
The IAlgManager is the interface implemented by the Algorithm Factory in the Application Manager to s...
Definition: IAlgManager.h:27
std::vector::end
T end(T...args)
OutputStream::m_optItemNames
Gaudi::Property< ItemNames > m_optItemNames
Definition: OutputStream.h:39
IConverter::createRep
virtual StatusCode createRep(DataObject *pObject, IOpaqueAddress *&refpAddress)=0
Convert the transient object to the requested representation.
OutputStreamAgent
Definition: OutputStreamAgent.h:30
OutputStream::m_requireAlgs
std::vector< Algorithm * > m_requireAlgs
Vector of Algorithms that this stream requires.
Definition: OutputStream.h:100
OutputStream::selectedObjects
IDataSelector * selectedObjects()
Return the list of selected objects.
Definition: OutputStream.h:159
ISvcLocator::as
SmartIF< IFace > as()
Definition: ISvcLocator.h:109
OutputStreamAgent.h
OutputStream::m_pDataProvider
SmartIF< IDataProviderSvc > m_pDataProvider
Keep reference to the data provider service.
Definition: OutputStream.h:79
DataStoreItem
Description of the DataStoreItem class.
Definition: DataStoreItem.h:17
OutputStream::m_doPreLoad
Gaudi::Property< bool > m_doPreLoad
Definition: OutputStream.h:47
StatusCode::isFailure
bool isFailure() const
Test for a status code of FAILURE.
Definition: StatusCode.h:61
DECLARE_COMPONENT
#define DECLARE_COMPONENT(type)
Definition: PluginService.h:33
OutputStream::m_agent
std::unique_ptr< OutputStreamAgent > m_agent
Keep reference of agent.
Definition: OutputStream.h:77
DataStoreItem::path
const std::string & path() const
Accessor: Retrieve load path.
Definition: DataStoreItem.h:58
OutputStream
A small to stream Data I/O.
Definition: OutputStream.h:29
OutputStream::m_acceptAlgs
std::vector< Algorithm * > m_acceptAlgs
Vector of Algorithms that this stream accepts.
Definition: OutputStream.h:98
std::string
STL class.
Incident.h
OutputStream::decodeAlgorithms
StatusCode decodeAlgorithms(Gaudi::Property< std::vector< std::string >> &theNames, std::vector< Algorithm * > &theAlgs)
Decode specified list of Algorithms.
Definition: OutputStream.cpp:506
IPersistencySvc.h
OutputStream::collect
virtual bool collect(IRegistry *dir, int level)
Store agent&#39;s classback.
Definition: OutputStream.cpp:216
SmartIF::get
TYPE * get() const
Get interface pointer.
Definition: SmartIF.h:82
OutputStream::findItem
DataStoreItem * findItem(const std::string &path)
Find single item identified by its path (exact match)
Definition: OutputStream.cpp:319
IDataManagerSvc::traverseSubTree
virtual StatusCode traverseSubTree(boost::string_ref sub_path, IDataStoreAgent *pAgent)=0
Analyse by traversing all data objects below the sub tree identified by its full path name...
OutputStream::requireAlgsHandler
void requireAlgsHandler(Gaudi::Details::PropertyBase &theProp)
Handler for RequireAlgs Property.
Definition: OutputStream.cpp:456
ISvcLocator::service
StatusCode service(const Gaudi::Utils::TypeNameString &name, T *&svc, bool createIf=true)
Templated method to access a service by name.
Definition: ISvcLocator.h:79
OutputStream::writeObjects
virtual StatusCode writeObjects()
Select the different objects and write them to file.
Definition: OutputStream.cpp:162
std::vector::push_back
T push_back(T...args)
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:106
OutputStream::m_pConversionSvc
SmartIF< IConversionSvc > m_pConversionSvc
Keep reference to the data conversion service.
Definition: OutputStream.h:83
IConversionSvc::connectOutput
virtual StatusCode connectOutput(const std::string &outputFile)=0
Connect the output file to the service.
OutputStream::initialize
StatusCode initialize() override
Initialize OutputStream.
Definition: OutputStream.cpp:40
DataStoreItem.h
IIncidentSvc::fireIncident
virtual void fireIncident(const Incident &incident)=0
Fire an Incident.
IDataManagerSvc.h
IDataProviderSvc.h
OutputStream::connectConversionSvc
virtual StatusCode connectConversionSvc()
Definition: OutputStream.cpp:355
CommonMessagingBase::warning
MsgStream & warning() const
shortcut for the method msgStream(MSG::WARNING)
Definition: CommonMessaging.h:109
OutputStream::m_algDependentItems
AlgDependentItems m_algDependentItems
Items to be saved for specific algorithms.
Definition: OutputStream.h:91
IConversionSvc::commitOutput
virtual StatusCode commitOutput(const std::string &outputFile, bool do_commit)=0
Commit pending output.
std::exception::what
T what(T...args)
IIncidentSvc.h
OutputStream::m_requireNames
Gaudi::Property< std::vector< std::string > > m_requireNames
Definition: OutputStream.h:59
OutputStream::vetoAlgsHandler
void vetoAlgsHandler(Gaudi::Details::PropertyBase &theProp)
Handler for VetoAlgs Property.
Definition: OutputStream.cpp:471
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
OutputStream::m_itemList
Items m_itemList
Vector of items to be saved to this stream.
Definition: OutputStream.h:87
OutputStream::addItem
void addItem(Items &itms, const std::string &descriptor)
Add item to output streamer list.
Definition: OutputStream.cpp:331
IRegistry.h
IRegistry
The IRegistry represents the entry door to the environment any data object residing in a transient da...
Definition: IRegistry.h:22
Gaudi::Details::PropertyBase
PropertyBase base class allowing PropertyBase* collections to be "homogeneous".
Definition: Property.h:32
OutputStream::m_algDependentItemList
Gaudi::Property< AlgDependentItemNames > m_algDependentItemList
Definition: OutputStream.h:41
OutputStream::m_pDataManager
SmartIF< IDataManagerSvc > m_pDataManager
Keep reference to the data manager service.
Definition: OutputStream.h:81
IDataProviderSvc::retrieveObject
virtual StatusCode retrieveObject(IRegistry *pDirectory, boost::string_ref path, DataObject *&pObject)=0
Retrieve object identified by its directory entry.
std::vector::clear
T clear(T...args)
OutputStream::clearSelection
void clearSelection()
Clear list of selected objects.
Definition: OutputStream.cpp:309
OutputStream::m_incidentSvc
SmartIF< IIncidentSvc > m_incidentSvc
Reference to the incident service.
Definition: OutputStream.h:72
std::exception
STL class.
Algorithm::serviceLocator
SmartIF< ISvcLocator > & serviceLocator() const override
The standard service locator.
Definition: Algorithm.cpp:815
OutputStream::decodeVetoAlgs
StatusCode decodeVetoAlgs()
Decode list of Algorithms that this stream is vetoed by.
Definition: OutputStream.cpp:464
IRegistry::object
virtual DataObject * object() const =0
Retrieve object behind the link.
std::set::count
T count(T...args)
IOpaqueAddress.h
OutputStream::acceptAlgsHandler
void acceptAlgsHandler(Gaudi::Details::PropertyBase &theProp)
Handler for AcceptAlgs Property.
Definition: OutputStream.cpp:441
OutputStream::execute
StatusCode execute() override
Working entry point.
Definition: OutputStream.cpp:142
std::unique_ptr::get
T get(T...args)
std::set::insert
T insert(T...args)
Algorithm
Base class from which all concrete algorithm classes should be derived.
Definition: Algorithm.h:79
std::find_if
T find_if(T...args)
std::vector::size
T size(T...args)
std::set
STL class.
OutputStream::m_storeName
Gaudi::Property< std::string > m_storeName
Definition: OutputStream.h:53
std::vector< DataObject * >
CommonMessagingBase::debug
MsgStream & debug() const
shortcut for the method msgStream(MSG::DEBUG)
Definition: CommonMessaging.h:115
IConversionSvc.h
std::vector::begin
T begin(T...args)
IRegistry::setAddress
virtual void setAddress(IOpaqueAddress *pAddress)=0
Set/Update Opaque storage address.
std::any_of
T any_of(T...args)
Algorithm::filterPassed
bool filterPassed() const override
Did this algorithm pass or fail its filter criterion for the last event?
Definition: Algorithm.cpp:768
std::string::c_str
T c_str(T...args)
Incident
Base class for all Incidents (computing events).
Definition: Incident.h:17
std::vector::back
T back(T...args)
AttribStringParser.h
OutputStream::m_doPreLoadOpt
Gaudi::Property< bool > m_doPreLoadOpt
Definition: OutputStream.h:49
ON_DEBUG
#define ON_DEBUG
Definition: OutputStream.cpp:27
OutputStream::decodeAlgorithm
Algorithm * decodeAlgorithm(const std::string &theName)
Decode a single algorithm name.
Definition: OutputStream.cpp:479
std::string::substr
T substr(T...args)
IAlgManager.h
OutputStream::OutputStream
OutputStream(const std::string &name, ISvcLocator *pSvcLocator)
Standard algorithm Constructor.
Definition: OutputStream.cpp:30
IPersistencySvc
Data persistency service interface.
Definition: IPersistencySvc.h:19
gaudirun.level
level
Definition: gaudirun.py:271
SmartIF::reset
void reset(TYPE *ptr=nullptr)
Set the internal pointer to the passed one disposing of the old one.
Definition: SmartIF.h:92
StatusCode::FAILURE
Definition: StatusCode.h:29
IOpaqueAddress
Opaque address interface definition.
Definition: IOpaqueAddress.h:23
StatusCode::ignore
void ignore() const
Definition: StatusCode.h:84
CommonMessagingBase::fatal
MsgStream & fatal() const
shortcut for the method msgStream(MSG::FATAL)
Definition: CommonMessaging.h:100
OutputStream::m_persName
Gaudi::Property< std::string > m_persName
Definition: OutputStream.h:55
OutputStream::m_vetoAlgs
std::vector< Algorithm * > m_vetoAlgs
Vector of Algorithms that this stream is vetoed by.
Definition: OutputStream.h:102
IRegistry::address
virtual IOpaqueAddress * address() const =0
Retrieve opaque storage address.
DataObject
A DataObject is the base class of any identifiable object on any data store.
Definition: DataObject.h:30
OutputStream::m_itemNames
Gaudi::Property< ItemNames > m_itemNames
Definition: OutputStream.h:38
OutputStream.h
OutputStream::collectObjects
virtual StatusCode collectObjects()
Collect all objects to be written to the output stream.
Definition: OutputStream.cpp:235
IConverter::fillRepRefs
virtual StatusCode fillRepRefs(IOpaqueAddress *pAddress, DataObject *pObject)=0
Resolve the references of the converted object.
std::stoi
T stoi(T...args)
ISvcLocator.h
toupper
void toupper(std::string &s)
Definition: StatusCodeSvc.cpp:10
strcasecmp.h
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209
OutputStream::decodeAcceptAlgs
StatusCode decodeAcceptAlgs()
Decode list of Algorithms that this stream accepts.
Definition: OutputStream.cpp:434
OutputStream::m_fireIncidents
bool m_fireIncidents
should I fire incidents for writing opening/closing etc? in the baseclass, always fire the incidents ...
Definition: OutputStream.h:69
std::vector::reserve
T reserve(T...args)
DataObject.h
OutputStream::m_optItemList
Items m_optItemList
Vector of optional items to be saved to this stream.
Definition: OutputStream.h:89