| The Gaudi Framework v29r0 (ff2e7097)

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

- File List
- File Members

TsDataSvc.cpp
Go to the documentation of this file.
1 //====================================================================
2 // TsDataSvc.cpp
3 //--------------------------------------------------------------------
4 //
5 // Package : System ( The LHCb Offline System)
6 //
7 // Description: implementation of the Transient data service: TsDataSvc
8 //
9 // Author : M.Frank
10 // History :
11 // +---------+----------------------------------------------+---------
12 // | Date | Comment | Who
13 // +---------+----------------------------------------------+---------
14 // | 29/10/98| Initial version | M.Frank
15 // | 20/2/99 | Automatic data preloading introduced. | M.Frank
16 // | 25/4/13 | Locking for concurrent access introduced. | D.Piparo
17 // +---------+----------------------------------------------+---------
18 //
19 //====================================================================
20 #define TSDATASVC_DATASVC_CPP
21
22 // Framework include files
23 #include "GaudiKernel/IConversionSvc.h"
24 #include "GaudiKernel/IConverter.h"
25 #include "GaudiKernel/IOpaqueAddress.h"
26
27 #include "GaudiKernel/DataObject.h"
28 #include "GaudiKernel/GaudiException.h"
29 #include "GaudiKernel/SvcFactory.h"
30 #include "GaudiKernel/xtoa.h"
31
32 #include "GaudiKernel/DataIncident.h"
33 #include "GaudiKernel/IIncidentSvc.h"
34 #include "GaudiKernel/RegistryEntry.h"
35 #include "GaudiKernel/TsDataSvc.h"
36
37 // Include files
38 #include <algorithm>
39 #include <cassert>
40 #include <cstdlib>
41 #include <mutex>
42 #include <sstream>
43 #include <vector>
44
45 // Macro to lock a scope
46 #define STD_LOCK_GUARD_MACRO std::lock_guard<tsDataSvcMutex> lock( m_accessMutex );
47
48 namespace
49 {
52 inline std::string itemToPath( int item )
53 {
54 std::ostringstream path;
55 path << '/' << item;
56 return path.str();
57 }
58 }
59
60 // If you absolutely need optimization: switch off dynamic_cast.
61 // This improves access to the data store roughly by 10 %
62 // for balanced trees.
63 //
64 // M.Frank
65 #define CAST_REGENTRY( x, y ) dynamic_cast<x>( y )
66 //#define CAST_REGENTRY(x,y) (x)(y)
67 typedef DataSvcHelpers::RegistryEntry RegEntry;
68
69 #define ON_DEBUG if ( msgLevel( MSG::DEBUG ) )
70 #define ON_VERBOSE if ( msgLevel( MSG::VERBOSE ) )
71
72 #define DEBMSG ON_DEBUG debug()
73 #define VERMSG ON_VERBOSE verbose()
74
78 StatusCode TsDataSvc::clearSubTree( const std::string& sub_tree_path )
79 {
80 DataObject* pObject = 0;
81 StatusCode status = findObject( sub_tree_path, pObject );
82 if ( status.isSuccess() ) {
83 RegEntry* node_entry = CAST_REGENTRY( RegEntry*, pObject->registry() );
84 if ( 0 != node_entry ) {
85 RegEntry* parent = node_entry->parentEntry();
86 if ( 0 != parent ) {
87 parent->remove( node_entry );
88 return StatusCode::SUCCESS;
89 }
90 return INVALID_PARENT;
91 }
92 return INVALID_OBJECT;
93 }
94 return status;
95 }
96
100 StatusCode TsDataSvc::clearSubTree( DataObject* pObject )
101 {
102 if ( checkRoot() ) {
103 RegEntry* entry = CAST_REGENTRY( RegEntry*, pObject->registry() );
104 if ( 0 != entry ) {
105 RegEntry* parent = entry->parentEntry();
106 if ( 0 != parent ) {
107 parent->remove( entry );
108 return SUCCESS;
109 }
110 return INVALID_PARENT;
111 }
112 return INVALID_OBJECT;
113 }
114 return INVALID_ROOT;
115 }
116
118 StatusCode TsDataSvc::clearStore()
119 {
120 if ( checkRoot() ) {
121 m_root->release();
122 m_root = 0;
123 return SUCCESS;
124 }
125 return INVALID_ROOT;
126 }
127
131 StatusCode TsDataSvc::traverseSubTree( const std::string& sub_tree_path, IDataStoreAgent* pAgent )
132 {
133 STD_LOCK_GUARD_MACRO
134 DataObject* pO = 0;
135 StatusCode status = findObject( sub_tree_path, pO );
136 if ( status.isSuccess() ) {
137 status = traverseSubTree( pO, pAgent );
138 }
139 return status;
140 }
141
143 StatusCode TsDataSvc::traverseSubTree( DataObject* pObject, IDataStoreAgent* pAgent )
144 {
145 STD_LOCK_GUARD_MACRO
146 if ( checkRoot() ) {
147 RegEntry* entry = CAST_REGENTRY( RegEntry*, pObject->registry() );
148 if ( 0 != entry ) {
149 return entry->traverseTree( pAgent );
150 }
151 return INVALID_OBJECT;
152 }
153 return INVALID_ROOT;
154 }
155
157 StatusCode TsDataSvc::traverseTree( IDataStoreAgent* pAgent )
158 {
159 STD_LOCK_GUARD_MACRO
160 if ( checkRoot() ) {
161 return m_root->traverseTree( pAgent );
162 }
163 return INVALID_ROOT;
164 }
165
170 StatusCode TsDataSvc::setRoot( std::string root_path, DataObject* pRootObj )
171 {
172 clearStore().ignore();
173 return i_setRoot( std::move( root_path ), pRootObj );
174 }
175
181 StatusCode TsDataSvc::i_setRoot( std::string root_path, DataObject* pRootObj )
182 {
183 if ( 0 != pRootObj ) {
184 m_root = new RegEntry( root_path );
185 m_root->makeHard( pRootObj );
186 m_root->setDataSvc( this );
187 // No done with GaudiHive. preLoad().ignore();
188 }
189 return SUCCESS;
190 }
191
196 StatusCode TsDataSvc::setRoot( std::string root_path, IOpaqueAddress* pRootAddr )
197 {
198 clearStore().ignore();
199 return i_setRoot( std::move( root_path ), pRootAddr );
200 }
201
207 StatusCode TsDataSvc::i_setRoot( std::string root_path, IOpaqueAddress* pRootAddr )
208 {
209 if ( 0 != pRootAddr ) {
210 m_root = new RegEntry( std::move( root_path ) );
211 m_root->makeHard( pRootAddr );
212 m_root->setDataSvc( this );
213 // Not done with GaudiHive. preLoad().ignore();
214 }
215 return SUCCESS;
216 }
217
219 StatusCode TsDataSvc::setDataLoader( IConversionSvc* pDataLoader, IDataProviderSvc* dpsvc )
220 {
221 if ( 0 != pDataLoader ) pDataLoader->addRef();
222 if ( 0 != m_dataLoader ) m_dataLoader->release();
223 if ( 0 != pDataLoader ) {
224 pDataLoader->setDataProvider( dpsvc == nullptr ? this : dpsvc ).ignore();
225 }
226 m_dataLoader = pDataLoader;
227 return SUCCESS;
228 }
229
231 StatusCode TsDataSvc::objectParent( const DataObject* pObject, IRegistry*& refpParent )
232 {
233 STD_LOCK_GUARD_MACRO
234 if ( pObject ) {
235 return objectParent( pObject->registry(), refpParent );
236 }
237 return INVALID_OBJECT;
238 }
240 StatusCode TsDataSvc::objectParent( const IRegistry* pRegistry, IRegistry*& refpParent )
241 {
242 STD_LOCK_GUARD_MACRO
243 if ( checkRoot() ) {
244 const RegEntry* node_entry = CAST_REGENTRY( const RegEntry*, pRegistry );
245 if ( node_entry ) {
246 refpParent = node_entry->parent();
247 return StatusCode::SUCCESS;
248 }
249 return INVALID_OBJECT;
250 }
251 return INVALID_ROOT;
252 }
253
255 StatusCode TsDataSvc::objectLeaves( const DataObject* pObject, std::vector<IRegistry*>& leaves )
256 {
257 STD_LOCK_GUARD_MACRO
258 if ( pObject ) {
259 return objectLeaves( pObject->registry(), leaves );
260 }
261 return INVALID_OBJECT;
262 }
263
267 StatusCode TsDataSvc::objectLeaves( const IRegistry* pRegistry, std::vector<IRegistry*>& leaves )
268 {
269 STD_LOCK_GUARD_MACRO
270 if ( checkRoot() ) {
271 const RegEntry* node_entry = CAST_REGENTRY( const RegEntry*, pRegistry );
272 if ( node_entry ) {
273 std::copy( node_entry->leaves().begin(), node_entry->leaves().end(), back_inserter( leaves ) );
274 // leaves = node_entry->leaves();
275 return StatusCode::SUCCESS;
276 }
277 return INVALID_OBJECT;
278 }
279 return INVALID_ROOT;
280 }
281
283 StatusCode TsDataSvc::registerAddress( const std::string& fullPath, IOpaqueAddress* pAddress )
284 {
285 if ( fullPath.length() > 0 ) {
286 if ( fullPath[0] != SEPARATOR ) {
287 return registerAddress( m_root, fullPath, pAddress );
288 }
289 IRegistry* pRegistry = 0;
290 return registerAddress( pRegistry, fullPath, pAddress );
291 }
292 return INVALID_OBJ_PATH;
293 }
294
296 StatusCode TsDataSvc::registerAddress( DataObject* parentObj, const std::string& objectPath, IOpaqueAddress* pAddress )
297 {
298 IRegistry* pRegistry = ( 0 == parentObj ) ? 0 : parentObj->registry();
299 return registerAddress( pRegistry, objectPath, pAddress );
300 }
301
303 StatusCode TsDataSvc::registerAddress( IRegistry* parentObj, const std::string& objPath, IOpaqueAddress* pAddress )
304 {
305 if ( checkRoot() ) {
306 if ( objPath.length() > 0 ) {
307 if ( 0 == parentObj ) {
308 if ( objPath[0] != SEPARATOR ) {
309 return registerAddress( m_root, objPath, pAddress );
310 }
311 std::string::size_type sep = objPath.find( SEPARATOR, 1 );
312 if ( sep != std::string::npos ) {
313 std::string p_path( objPath, 0, sep );
314 if ( p_path == m_rootName ) {
315 std::string o_path( objPath, sep, objPath.length() );
316 return registerAddress( m_root, o_path, pAddress );
317 }
318 }
319 return INVALID_PARENT;
320 }
321 if ( objPath[0] != SEPARATOR ) {
322 std::string path;
323 path = SEPARATOR;
324 path += objPath;
325 return registerAddress( parentObj, path, pAddress );
326 }
327 RegEntry* par_entry = CAST_REGENTRY( RegEntry*, parentObj );
328 if ( 0 != par_entry ) {
329 std::string::size_type sep = objPath.rfind( SEPARATOR );
330 if ( sep > 0 && sep != std::string::npos ) {
331 std::string p_path( objPath, 0, sep );
332 std::string o_path( objPath, sep, objPath.length() );
333 RegEntry* p_entry = par_entry->findLeaf( p_path );
334 // Create default object leafs if the
335 // intermediate nodes are not present
336 if ( 0 == p_entry && m_forceLeaves ) {
337 DataObject* pLeaf = createDefaultObject();
338 StatusCode sc = registerObject( par_entry->identifier(), p_path, pLeaf );
339 if ( !sc.isSuccess() ) {
340 delete pLeaf;
341 }
342 p_entry = par_entry->findLeaf( p_path );
343 }
344 if ( 0 != p_entry ) {
345 return registerAddress( p_entry, o_path, pAddress );
346 }
347 return INVALID_PARENT;
348 }
349 StatusCode status = par_entry->add( objPath, pAddress );
350 if ( status.isSuccess() ) {
351 return status;
352 }
353 return DOUBL_OBJ_PATH;
354 }
355 return INVALID_PARENT;
356 }
357 return INVALID_OBJ_PATH;
358 }
359 return INVALID_ROOT;
360 }
361
363 StatusCode TsDataSvc::unregisterAddress( const std::string& fullPath )
364 {
365 if ( fullPath.length() > 0 ) {
366 IRegistry* pRegistry = 0;
367 if ( fullPath[0] != SEPARATOR ) {
368 return unregisterAddress( m_root, fullPath );
369 }
370 return unregisterAddress( pRegistry, fullPath );
371 }
372 return INVALID_OBJ_PATH;
373 }
374
376 StatusCode TsDataSvc::unregisterAddress( DataObject* pParent, const std::string& objPath )
377 {
378 IRegistry* pRegistry = ( 0 == pParent ) ? 0 : pParent->registry();
379 return unregisterAddress( pRegistry, objPath );
380 }
381
383 StatusCode TsDataSvc::unregisterAddress( IRegistry* pParent, const std::string& objPath )
384 {
385 if ( checkRoot() ) {
386 if ( objPath.length() > 0 ) {
387 if ( 0 == pParent ) {
388 if ( objPath[0] != SEPARATOR ) {
389 return unregisterAddress( m_root, objPath );
390 }
391 std::string::size_type sep = objPath.find( SEPARATOR, 1 );
392 if ( sep != std::string::npos ) {
393 std::string p_path( objPath, 0, sep );
394 if ( p_path == m_rootName ) {
395 std::string o_path( objPath, sep, objPath.length() );
396 return unregisterAddress( m_root, o_path );
397 }
398 }
399 return INVALID_PARENT;
400 }
401 if ( objPath[0] != SEPARATOR ) {
402 std::string path;
403 path = SEPARATOR;
404 path += objPath;
405 return unregisterAddress( pParent, path );
406 }
407 RegEntry* node_entry = CAST_REGENTRY( RegEntry*, pParent );
408 if ( 0 != node_entry ) {
409 RegEntry* leaf_entry = node_entry->findLeaf( objPath );
410 if ( 0 != leaf_entry ) {
411 std::string::size_type sep = objPath.rfind( SEPARATOR );
412 if ( sep > 0 && sep != std::string::npos ) {
413 std::string path = objPath.substr( sep );
414 return unregisterAddress( leaf_entry->parent(), path );
415 }
416 StatusCode status = node_entry->remove( objPath );
417 if ( status.isSuccess() ) {
418 return status;
419 }
420 }
421 }
422 return INVALID_PARENT;
423 }
424 return INVALID_OBJ_PATH;
425 }
426 return INVALID_ROOT;
427 }
428
430 StatusCode TsDataSvc::registerObject( const std::string& fullPath, DataObject* pObject )
431 {
432 return registerObject( 0, fullPath, pObject );
433 }
434
436 StatusCode TsDataSvc::registerObject( const std::string& parentPath, const std::string& objPath, DataObject* pObject )
437 {
438 DataObject* pO = 0;
439 StatusCode status = retrieveObject( parentPath, pO );
440 if ( !status.isSuccess() && m_forceLeaves ) {
441 pO = createDefaultObject();
442 status = registerObject( parentPath, pO );
443 if ( !status.isSuccess() ) {
444 pO->release();
445 }
446 }
447 if ( status.isSuccess() ) {
448 status = registerObject( pO, objPath, pObject );
449 }
450 return status;
451 }
452
454 StatusCode TsDataSvc::registerObject( const std::string& parentPath, int item, DataObject* pObject )
455 {
456 return registerObject( parentPath, itemToPath( item ), pObject );
457 }
458
460 StatusCode TsDataSvc::registerObject( DataObject* parentObj, int item, DataObject* pObject )
461 {
462 return registerObject( parentObj, itemToPath( item ), pObject );
463 }
464
466 StatusCode TsDataSvc::registerObject( DataObject* parentObj, const std::string& objPath, DataObject* pObject )
467 {
468 if ( checkRoot() ) {
469 if ( 0 == parentObj ) {
470 if ( objPath.length() > 0 ) {
471 if ( objPath[0] == SEPARATOR ) {
472 std::string::size_type sep = objPath.find( SEPARATOR, 1 );
473 if ( sep != std::string::npos ) {
474 std::string p_path( objPath, 0, sep );
475 std::string o_path( objPath, sep, objPath.length() );
476 return registerObject( p_path, o_path, pObject );
477 }
478 } else {
479 return registerObject( m_rootName, objPath, pObject );
480 }
481 }
482 return INVALID_OBJ_PATH;
483 }
484 RegEntry* node_entry = CAST_REGENTRY( RegEntry*, parentObj->registry() );
485 if ( 0 != node_entry ) {
486 StatusCode status = INVALID_PARENT;
487 std::string::size_type sep = objPath.find( SEPARATOR, 1 );
488 if ( sep != std::string::npos ) {
489 std::string p_path( objPath, 0, sep );
490 std::string o_path( objPath, sep, objPath.length() );
491 RegEntry* par_entry = node_entry->findLeaf( p_path );
492 // Create default object leafs if the
493 // intermediate nodes are not present
494 if ( 0 == par_entry && m_forceLeaves ) {
495 DataObject* pLeaf = createDefaultObject();
496 StatusCode sc = registerObject( parentObj, p_path, pLeaf );
497 if ( !sc.isSuccess() ) {
498 delete pLeaf;
499 }
500 par_entry = node_entry->findLeaf( p_path );
501 } else if ( 0 != par_entry && par_entry->object() == 0 ) {
502 status = retrieveEntry( node_entry, p_path, par_entry );
503 if ( !status.isSuccess() && !par_entry->address() && m_forceLeaves ) {
504 DataObject* pLeaf = createDefaultObject();
505 StatusCode sc = registerObject( parentObj, p_path, pLeaf );
506 if ( !sc.isSuccess() ) {
507 delete pLeaf;
508 }
509 par_entry = node_entry->findLeaf( p_path );
510 }
511 }
512 node_entry = par_entry;
513 if ( 0 != node_entry ) {
514 DataObject* obj = node_entry->object();
515 if ( 0 != obj ) {
516 status = registerObject( obj, o_path, pObject );
517 }
518 }
519 } else {
520 RegEntry* leaf = node_entry->findLeaf( objPath );
521 if ( 0 == leaf ) {
522 status = node_entry->add( objPath, pObject );
523 } else {
524 DataObject* obj = leaf->object();
525 if ( 0 == obj ) {
526 if ( 0 == pObject ) {
527 error() << "registerObject: trying to register null DataObject" << endmsg;
528 return StatusCode::FAILURE;
529 } else {
530 pObject->setRegistry( leaf );
531 }
532 leaf->setAddress( 0 );
533 leaf->setObject( pObject );
534 status = StatusCode::SUCCESS;
535 } else {
536 status = DOUBL_OBJ_PATH;
537 }
538 }
539 }
540 return status;
541 }
542 return INVALID_PARENT;
543 }
544 return INVALID_ROOT;
545 }
546
548 StatusCode TsDataSvc::unregisterObject( const std::string& fullPath )
549 {
550 DataObject* pObject = 0;
551 StatusCode status = findObject( fullPath, pObject );
552 if ( status.isSuccess() ) {
553 RegEntry* pEntry = CAST_REGENTRY( RegEntry*, pObject->registry() );
554 if ( 0 != pEntry ) {
555 if ( pEntry->isEmpty() ) {
556 RegEntry* pParent = pEntry->parentEntry();
557 if ( 0 != pParent ) {
558 if ( 0 != pObject ) {
559 pObject->addRef();
560 }
561 pParent->remove( pEntry );
562 return StatusCode::SUCCESS;
563 }
564 return INVALID_PARENT;
565 }
566 return DIR_NOT_EMPTY;
567 }
568 return INVALID_ROOT;
569 }
570 return status;
571 }
572
574 StatusCode TsDataSvc::unregisterObject( const std::string& parentPath, const std::string& objPath )
575 {
576 DataObject* pO = 0;
577 StatusCode status = findObject( parentPath, pO );
578 if ( status.isSuccess() ) {
579 status = unregisterObject( pO, objPath );
580 }
581 return status;
582 }
583
585 StatusCode TsDataSvc::unregisterObject( const std::string& parentPath, int item )
586 {
587 return unregisterObject( parentPath, itemToPath( item ) );
588 }
589
591 StatusCode TsDataSvc::unregisterObject( DataObject* pObject )
592 {
593 if ( checkRoot() ) {
594 RegEntry* entry = m_root->findLeaf( pObject );
595 if ( 0 != entry ) {
596 RegEntry* parent = entry->parentEntry();
597 if ( 0 != parent ) {
598 if ( entry->isEmpty() ) {
599 if ( 0 != entry->object() ) {
600 entry->object()->addRef();
601 }
602 if ( 0 != parent ) {
603 parent->remove( entry );
604 }
605 return SUCCESS;
606 }
607 return INVALID_PARENT;
608 }
609 return DIR_NOT_EMPTY;
610 }
611 return INVALID_OBJECT;
612 }
613 return INVALID_ROOT;
614 }
615
617 StatusCode TsDataSvc::unregisterObject( DataObject* pParentObj, const std::string& objectPath )
618 {
619 if ( checkRoot() ) {
620 try {
621 RegEntry* parent = CAST_REGENTRY( RegEntry*, pParentObj->registry() );
622 if ( 0 != parent ) {
623 RegEntry* entry = parent->findLeaf( objectPath );
624 if ( 0 != entry ) {
625 if ( entry->isEmpty() ) {
626 if ( 0 != entry->object() ) {
627 entry->object()->addRef();
628 }
629 parent->remove( entry );
630 return SUCCESS;
631 }
632 return DIR_NOT_EMPTY;
633 }
634 return INVALID_OBJECT;
635 }
636 } catch ( ... ) {
637 }
638 return INVALID_PARENT;
639 }
640 return INVALID_ROOT;
641 }
642
644 StatusCode TsDataSvc::unregisterObject( DataObject* pParentObj, int item )
645 {
646 return unregisterObject( pParentObj, itemToPath( item ) );
647 }
648
651 DataObject* TsDataSvc::handleDataFault( IRegistry* pReg, const std::string& path )
652 {
653 if ( m_enableFaultHdlr ) {
654 IRegistry* pLeaf = 0;
655 if ( pReg && path.length() == 0 ) {
656 DataIncident incident( name(), m_faultName, pReg->identifier() );
657 m_incidentSvc->fireIncident( incident );
658 return pReg->object();
659 } else if ( pReg ) {
660 std::string p = pReg->identifier();
661 if ( path[0] != SEPARATOR ) p += SEPARATOR;
662 p += path;
663 DataIncident incident( name(), m_faultName, p );
664 m_incidentSvc->fireIncident( incident );
665 pLeaf = m_root->findLeaf( p );
666 } else {
667 std::string p = m_root->identifier();
668 if ( path[0] != SEPARATOR ) p += SEPARATOR;
669 p += path;
670 DataIncident incident( name(), m_faultName, p );
671 m_incidentSvc->fireIncident( incident );
672 pLeaf = m_root->findLeaf( p );
673 }
674 if ( pLeaf ) {
675 return pLeaf->object();
676 }
677 }
678 return 0;
679 }
680
684 StatusCode TsDataSvc::loadObject( IRegistry* pRegistry )
685 {
686 IConversionSvc* pLoader = getDataLoader( pRegistry );
687 return loadObject( pLoader, pRegistry );
688 }
689
693 StatusCode TsDataSvc::loadObject( IConversionSvc* pLoader, IRegistry* pRegistry )
694 {
695 STD_LOCK_GUARD_MACRO
696 StatusCode status = INVALID_OBJ_ADDR;
697 DataObject* pObject = 0;
698 if ( 0 == pLoader ) { // Precondition: Data loader must be present
699 if ( handleDataFault( pRegistry ) != 0 )
700 return SUCCESS;
701 else
702 return NO_DATA_LOADER;
703 }
704 if ( 0 == pRegistry ) { // Precondition: Directory must be valid
705 if ( handleDataFault( pRegistry ) != 0 )
706 return SUCCESS;
707 else
708 return INVALID_OBJ_ADDR;
709 }
710
711 VERMSG << "Requested object " << pRegistry->identifier() << endmsg;
712
713 if ( m_enableAccessHdlr ) {
714 // Fire data access incident
715 DataIncident incident( name(), m_accessName, pRegistry->identifier() );
716 m_incidentSvc->fireIncident( incident );
717 }
718 if ( m_inhibitPathes.size() > 0 ) {
719 const std::string& ident = pRegistry->identifier();
720 std::vector<std::string>::iterator inhibit = std::find( m_inhibitPathes.begin(), m_inhibitPathes.end(), ident );
721 if ( inhibit != m_inhibitPathes.end() ) {
722 return NO_ACCESS;
723 }
724 }
725 IOpaqueAddress* pAddress = pRegistry->address();
726 if ( 0 == pAddress ) { // Precondition:
727 return INVALID_OBJ_ADDR; // Address must be valid
728 }
729 try {
730 status = pLoader->createObj( pAddress, pObject ); // Call data loader
731 if ( status.isSuccess() ) {
732
733 VERMSG << "Object " << pRegistry->identifier() << " created" << endmsg;
734
735 RegEntry* pEntry = CAST_REGENTRY( RegEntry*, pRegistry );
736 pEntry->setObject( pObject );
737
738 VERMSG << "Filling object " << pRegistry->identifier() << endmsg;
739 status = pLoader->fillObjRefs( pAddress, pObject );
740 }
741 } catch ( const GaudiException& exc ) {
742 if ( handleDataFault( pRegistry ) != 0 ) {
743 return SUCCESS;
744 }
745 throw GaudiException( "GaudiException in loadObject() " + pRegistry->identifier(), name(), StatusCode::FAILURE,
746 exc );
747 } catch ( const std::exception& x ) {
748 if ( handleDataFault( pRegistry ) != 0 ) {
749 return SUCCESS;
750 }
751 throw GaudiException( "std::exception in loadObject() " + pRegistry->identifier() + ": " +
752 System::typeinfoName( typeid( x ) ) + ", " + x.what(),
753 name(), StatusCode::FAILURE );
754 } catch ( ... ) {
755 if ( handleDataFault( pRegistry ) != 0 ) {
756 return SUCCESS;
757 }
758 throw GaudiException( "UNKN exception in loadObject() " + pRegistry->identifier(), name(), StatusCode::FAILURE );
759 }
760 if ( !status.isSuccess() ) {
761 if ( handleDataFault( pRegistry ) != 0 ) {
762 return StatusCode::SUCCESS;
763 }
764 }
765 ON_VERBOSE if ( status.isSuccess() )
766 {
767 verbose() << "Object " << pRegistry->identifier() << " successfully loaded" << endmsg;
768 }
769 return status;
770 }
771
773 StatusCode TsDataSvc::retrieveEntry( RegEntry* parentObj, const std::string& path, RegEntry*& pEntry )
774 {
775 STD_LOCK_GUARD_MACRO
776 std::string::size_type sep = path.find( SEPARATOR, 1 );
777 StatusCode status = StatusCode( INVALID_ROOT, true );
778 pEntry = 0;
779 // A.Valassi 16.08.2001 avoid core dump if store is empty
780 if ( checkRoot() ) {
781 if ( 0 == parentObj ) {
782 if ( path.length() == 0 || path == m_rootName ) {
783 return retrieveEntry( m_root, "", pEntry );
784 } else if ( path[0] != SEPARATOR ) {
785 return retrieveEntry( m_root, path, pEntry );
786 } else if ( sep != std::string::npos ) {
787 if ( m_root->object() == 0 ) {
788 RegEntry* r = 0;
789 status = retrieveEntry( m_root, "", r );
790 if ( !status.isSuccess() ) {
791 return status;
792 }
793 }
794 std::string o_path( path, sep, path.length() );
795 return retrieveEntry( m_root, o_path, pEntry );
796 }
797 return INVALID_OBJ_PATH;
798 }
799 if ( sep != std::string::npos ) { // the string contains a separator (after pos 0)
800 std::string p_path( path, 0, sep );
801 std::string o_path( path, sep, path.length() );
802 if ( !parentObj->object() ) { // if the parent object has not been loaded yet, load it now
803 status = loadObject( parentObj );
804 if ( !status.isSuccess() ) {
805 return status;
806 }
807 }
808 RegEntry* root_entry = parentObj->findLeaf( p_path );
809 if ( !root_entry && m_enableFaultHdlr ) {
810 // If not even the parent is there, an incident
811 // to load the parent must be fired...
812 handleDataFault( parentObj, p_path );
813 root_entry = parentObj->findLeaf( p_path );
814 }
815 if ( root_entry ) {
816 DataObject* pO = root_entry->object();
817 if ( 0 == pO ) {
818 // Object is not loaded: load the object if at all possible
819 status = loadObject( root_entry );
820 if ( !status.isSuccess() ) {
821 return status;
822 }
823 }
824 if ( root_entry->isSoft() ) {
825 root_entry = CAST_REGENTRY( RegEntry*, pO->registry() );
826 }
827 return retrieveEntry( root_entry, o_path, pEntry );
828 }
829 return status;
830 } else if ( path.length() == 0 ) {
831 pEntry = parentObj;
832 } else {
833 if ( !parentObj->object() ) { // if the parent object has not been loaded yet, load it now
834 status = loadObject( parentObj );
835 if ( !status.isSuccess() ) {
836 return status;
837 }
838 }
839 // last leave in search: find leaf and load
840 pEntry = parentObj->findLeaf( path );
841 // If no registry entry was found, trigger incident for action-on-demand
842 if ( !pEntry && m_enableFaultHdlr ) {
843 handleDataFault( parentObj, path );
844 pEntry = ( 0 == path.length() ) ? parentObj : parentObj->findLeaf( path );
845 }
846 }
847 // Check results and return
848 if ( 0 == pEntry ) {
849 status = INVALID_OBJ_PATH;
850 } else if ( 0 == pEntry->object() ) {
851 status = loadObject( pEntry );
852 } else if ( m_enableAccessHdlr ) {
853 // Fire data access incident
854 // I do not know if this is a good idea....
855 // This fires too often!
856 //
857 // DataIncident incident(name(), m_accessName, pEntry->identifier());
858 // m_incidentSvc->fireIncident(incident);
859 status = SUCCESS;
860 } else {
861 status = SUCCESS;
862 }
863 }
864 return status;
865 }
866
868 StatusCode TsDataSvc::retrieveObject( IRegistry* pRegistry, const std::string& path, DataObject*& pObject )
869 {
870 STD_LOCK_GUARD_MACRO
871 pObject = 0;
872 RegEntry *result = 0, *parent = CAST_REGENTRY( RegEntry *, pRegistry );
873 StatusCode status = retrieveEntry( parent, path, result );
874 if ( status.isSuccess() ) {
875 pObject = result->object();
876 }
877 return status;
878 }
879
881 StatusCode TsDataSvc::retrieveObject( const std::string& fullPath, DataObject*& pObject )
882 {
883 IRegistry* nullDir = 0;
884 return retrieveObject( nullDir, fullPath, pObject );
885 }
886
888 StatusCode TsDataSvc::retrieveObject( const std::string& parentPath, const std::string& objectPath,
889 DataObject*& pObject )
890 {
891 DataObject* parent = 0;
892 StatusCode status = retrieveObject( parentPath, parent );
893 if ( status.isSuccess() ) {
894 status = retrieveObject( parent, objectPath, pObject );
895 }
896 return status;
897 }
898
900 StatusCode TsDataSvc::retrieveObject( const std::string& parentPath, int item, DataObject*& pObject )
901 {
902 return retrieveObject( parentPath, itemToPath( item ), pObject );
903 }
904
906 StatusCode TsDataSvc::retrieveObject( DataObject* parentObj, const std::string& path, DataObject*& pObject )
907 {
908 IRegistry* pRegistry = ( 0 == parentObj ) ? 0 : parentObj->registry();
909 return retrieveObject( pRegistry, path, pObject );
910 }
911
913 StatusCode TsDataSvc::retrieveObject( DataObject* parentObj, int item, DataObject*& pObject )
914 {
915 return retrieveObject( parentObj, itemToPath( item ), pObject );
916 }
917
919 StatusCode TsDataSvc::findObject( IRegistry* pRegistry, const std::string& path, DataObject*& pObject )
920 {
921 STD_LOCK_GUARD_MACRO
922 pObject = 0;
923 IRegistry* pReg = ( 0 == pRegistry ) ? m_root : pRegistry;
924 RegEntry* root_entry = CAST_REGENTRY( RegEntry*, pReg );
925 if ( 0 != root_entry ) {
926 if ( path.length() > 0 ) {
927 pReg = root_entry->find( path );
928 }
929 if ( 0 == pReg ) {
930 return INVALID_OBJ_PATH;
931 }
932 pObject = pReg->object();
933 }
934 return ( 0 == pObject ) ? OBJ_NOT_LOADED : IDataProviderSvc_NO_ERROR;
935 }
936
938 StatusCode TsDataSvc::findObject( const std::string& path, DataObject*& pObject )
939 {
940 STD_LOCK_GUARD_MACRO
941 pObject = 0;
942 if ( checkRoot() ) {
943 if ( path.length() == 0 || path == m_rootName ) {
944 pObject = m_root->object();
945 return ( 0 == pObject ) ? OBJ_NOT_LOADED : IDataProviderSvc_NO_ERROR;
946 } else if ( path[0] != SEPARATOR ) {
947 return findObject( m_rootName, path, pObject );
948 }
949 return findObject( (IRegistry*)0, path, pObject );
950 }
951 return INVALID_ROOT;
952 }
953
955 StatusCode TsDataSvc::findObject( const std::string& parentPath, const std::string& objectPath, DataObject*& pObject )
956 {
957 DataObject* parent = 0;
958 StatusCode status = findObject( parentPath, parent );
959 if ( status.isSuccess() ) {
960 status = findObject( parent, objectPath, pObject );
961 }
962 return status;
963 }
964
966 StatusCode TsDataSvc::findObject( const std::string& parentPath, int item, DataObject*& pObject )
967 {
968 return findObject( parentPath, itemToPath( item ), pObject );
969 }
970
972 StatusCode TsDataSvc::findObject( DataObject* parentObj, int item, DataObject*& pObject )
973 {
974 return findObject( parentObj, itemToPath( item ), pObject );
975 }
976
978 StatusCode TsDataSvc::findObject( DataObject* parentObj, const std::string& path, DataObject*& pObject )
979 {
980 IRegistry* pDir = ( 0 == parentObj ) ? 0 : parentObj->registry();
981 return findObject( pDir, path, pObject );
982 }
983
985 StatusCode TsDataSvc::updateObject( const std::string& updatePath )
986 {
987 DataObject* pO = 0;
988 StatusCode status = findObject( updatePath, pO );
989 if ( status.isSuccess() ) {
990 return updateObject( pO );
991 }
992 return retrieveObject( updatePath, pO );
993 }
994
996 StatusCode TsDataSvc::updateObject( IRegistry* pRegistry )
997 {
998 if ( 0 == pRegistry ) { // Precondition:
999 return INVALID_OBJ_ADDR; // Addres must be valid
1000 }
1001 DataObject* toUpdate = pRegistry->object();
1002 if ( 0 == toUpdate ) { // Try first to load
1003 return loadObject( pRegistry );
1004 }
1005 return updateObject( toUpdate );
1006 }
1007
1009 StatusCode TsDataSvc::updateObject( DataObject* toUpdate )
1010 {
1011 STD_LOCK_GUARD_MACRO
1012 StatusCode status = INVALID_OBJ_ADDR;
1013 if ( 0 == toUpdate ) { // Precondition:
1014 return INVALID_OBJECT; // Address must be valid
1015 }
1016 IRegistry* pRegistry = toUpdate->registry(); // Precondition:
1017 if ( 0 == pRegistry ) { // Need valid registry
1018 return INVALID_OBJECT;
1019 }
1020 IOpaqueAddress* pAddress = pRegistry->address(); // Precondition:
1021 if ( 0 == pAddress ) { // Need valid address
1022 return INVALID_OBJ_ADDR;
1023 }
1024 IConversionSvc* pLoader = getDataLoader( pRegistry );
1025 if ( 0 == pLoader ) { // Precondition:
1026 return NO_DATA_LOADER; // Data loader must be present
1027 }
1028 if ( m_inhibitPathes.size() > 0 ) {
1029 const std::string& ident = pRegistry->identifier();
1030 std::vector<std::string>::iterator inhibit = std::find( m_inhibitPathes.begin(), m_inhibitPathes.end(), ident );
1031 if ( inhibit != m_inhibitPathes.end() ) {
1032 return NO_ACCESS;
1033 }
1034 }
1035 try {
1036 status = pLoader->updateObj( pAddress, toUpdate ); // Call data loader
1037 if ( status.isSuccess() ) {
1038 status = pLoader->updateObjRefs( pAddress, toUpdate );
1039 }
1040 } catch ( const GaudiException& exc ) {
1041 throw GaudiException( "GaudiException in updateObject() " + pRegistry->name(), name(), StatusCode::FAILURE, exc );
1042 } catch ( const std::exception& x ) {
1043 throw GaudiException( "std::exception in updateObject() " + pRegistry->name() + ": " +
1044 System::typeinfoName( typeid( x ) ) + ", " + x.what(),
1045 name(), StatusCode::FAILURE );
1046 } catch ( ... ) {
1047 throw GaudiException( "UNKN exception in updateObject() " + pRegistry->name(), name(), StatusCode::FAILURE );
1048 }
1049 return status;
1050 }
1051
1053 StatusCode TsDataSvc::updateObject( const std::string& parentPath, const std::string& updatePath )
1054 {
1055 DataObject* pParent = 0;
1056 StatusCode status = findObject( parentPath, pParent );
1057 if ( status.isSuccess() ) {
1058 status = updateObject( pParent, updatePath );
1059 }
1060 return status;
1061 }
1062
1064 StatusCode TsDataSvc::updateObject( DataObject* parent, const std::string& updatePath )
1065 {
1066 DataObject* pObject = 0;
1067 StatusCode status = findObject( parent, updatePath, pObject );
1068 if ( status.isSuccess() ) {
1069 status = updateObject( pObject );
1070 }
1071 return status;
1072 }
1073
1074 // Link object
1075 StatusCode TsDataSvc::linkObject( IRegistry* from, const std::string& objPath, DataObject* to )
1076 {
1077 STD_LOCK_GUARD_MACRO
1078 if ( checkRoot() ) {
1079 try {
1080 RegEntry* from_entry = CAST_REGENTRY( RegEntry*, from );
1081 if ( 0 != from_entry ) {
1082 // First check if both objects are already registered to the store
1083 RegEntry* to_entry = m_root->findLeaf( to );
1084 if ( 0 == to_entry ) {
1085 return INVALID_OBJECT;
1086 } else {
1087 std::string::size_type sep = objPath.rfind( SEPARATOR );
1088 if ( sep > 0 && sep != std::string::npos ) { // in case the objPath is a sub-directory itself
1089 DataObject* pO = 0;
1090 std::string fromPath( objPath, 0, sep );
1091 StatusCode sc = retrieveObject( from, fromPath, pO );
1092 if ( sc.isSuccess() ) {
1093 std::string toPath( objPath, sep, objPath.length() );
1094 sc = linkObject( pO->registry(), toPath, to );
1095 }
1096 return sc;
1097 }
1098 // Now register the soft link
1099 StatusCode status = from_entry->add( objPath, to, true );
1100 return status.isSuccess() ? IDataProviderSvc_NO_ERROR : DOUBL_OBJ_PATH;
1101 }
1102 }
1103 } catch ( ... ) {
1104 }
1105 return INVALID_PARENT;
1106 }
1107 return INVALID_ROOT;
1108 }
1109
1111 StatusCode TsDataSvc::linkObject( const std::string& fullPath, DataObject* to )
1112 {
1113 STD_LOCK_GUARD_MACRO
1114 if ( fullPath.length() > 0 ) {
1115 if ( fullPath[0] != SEPARATOR ) {
1116 return linkObject( m_rootName, fullPath, to );
1117 }
1118 std::string::size_type sep = fullPath.rfind( SEPARATOR );
1119 std::string objPath( fullPath, sep, fullPath.length() );
1120 std::string fromPath( fullPath, 0, sep );
1121 return linkObject( fromPath, objPath, to );
1122 }
1123 return INVALID_OBJ_PATH;
1124 }
1125
1127 StatusCode TsDataSvc::linkObject( const std::string& from, const std::string& objPath, DataObject* to )
1128 {
1129 STD_LOCK_GUARD_MACRO
1130 DataObject* pO = 0;
1131 StatusCode status = retrieveObject( from, pO );
1132 if ( status.isSuccess() ) {
1133 return linkObject( pO->registry(), objPath, to );
1134 }
1135 return status;
1136 }
1137
1139 StatusCode TsDataSvc::linkObject( DataObject* from, const std::string& objPath, DataObject* to )
1140 {
1141 STD_LOCK_GUARD_MACRO
1142 if ( 0 != from ) {
1143 IRegistry* from_entry = from->registry();
1144 if ( 0 != from_entry ) {
1145 return linkObject( from_entry, objPath, to );
1146 }
1147 }
1148 return INVALID_PARENT;
1149 }
1150
1152 StatusCode TsDataSvc::unlinkObject( IRegistry* from, const std::string& objPath )
1153 {
1154 STD_LOCK_GUARD_MACRO
1155 if ( checkRoot() ) {
1156 try {
1157 RegEntry* from_entry = CAST_REGENTRY( RegEntry*, from );
1158 if ( 0 != from_entry ) {
1159 std::string::size_type sep = objPath.rfind( SEPARATOR );
1160 if ( sep > 0 && sep != std::string::npos ) { // in case the objPath is a sub-directory itself
1161 DataObject* pO = 0;
1162 std::string fromPath( objPath, 0, sep );
1163 StatusCode sc = findObject( from, fromPath, pO );
1164 if ( sc.isSuccess() ) {
1165 std::string toPath( objPath, sep, objPath.length() );
1166 sc = unlinkObject( pO->registry(), toPath );
1167 }
1168 return sc;
1169 }
1170 StatusCode status = from_entry->remove( objPath );
1171 if ( status.isSuccess() ) {
1172 return status;
1173 }
1174 return INVALID_OBJ_PATH;
1175 }
1176 } catch ( ... ) {
1177 }
1178 return INVALID_PARENT;
1179 }
1180 return INVALID_ROOT;
1181 }
1182
1184 StatusCode TsDataSvc::unlinkObject( const std::string& fullPath )
1185 {
1186 if ( fullPath.length() > 0 ) {
1187 if ( fullPath[0] != SEPARATOR ) {
1188 return unlinkObject( m_rootName, fullPath );
1189 }
1190 std::string::size_type sep = fullPath.rfind( SEPARATOR );
1191 std::string objPath( fullPath, sep, fullPath.length() );
1192 std::string fromPath( fullPath, 0, sep );
1193 return unlinkObject( fromPath, objPath );
1194 }
1195 return INVALID_OBJ_PATH;
1196 }
1197
1199 StatusCode TsDataSvc::unlinkObject( const std::string& from, const std::string& objPath )
1200 {
1201 DataObject* pObject = 0;
1202 StatusCode status = findObject( from, pObject );
1203 if ( status.isSuccess() ) {
1204 status = unlinkObject( pObject->registry(), objPath );
1205 }
1206 return status;
1207 }
1208
1210 StatusCode TsDataSvc::unlinkObject( DataObject* from, const std::string& objPath )
1211 {
1212 if ( checkRoot() ) {
1213 IRegistry* from_entry = m_root->findLeaf( from );
1214 return unlinkObject( from_entry, objPath );
1215 }
1216 return INVALID_ROOT;
1217 }
1218
1220 StatusCode TsDataSvc::addPreLoadItem( const DataStoreItem& item )
1221 {
1222 LoadItems::iterator i = std::find( m_preLoads.begin(), m_preLoads.end(), item );
1223 if ( i == m_preLoads.end() ) {
1224 m_preLoads.push_back( item );
1225 }
1226 return StatusCode::SUCCESS;
1227 }
1228
1230 StatusCode TsDataSvc::addPreLoadItem( const std::string& itemPath )
1231 {
1232 return addPreLoadItem( DataStoreItem( itemPath, 1 ) );
1233 }
1234
1236 StatusCode TsDataSvc::removePreLoadItem( const DataStoreItem& item )
1237 {
1238 LoadItems::iterator i = std::remove( m_preLoads.begin(), m_preLoads.end(), item );
1239 if ( i != m_preLoads.end() ) {
1240 m_preLoads.erase( i, m_preLoads.end() );
1241 }
1242 return StatusCode::SUCCESS;
1243 }
1244
1246 StatusCode TsDataSvc::removePreLoadItem( const std::string& itemPath )
1247 {
1248 return removePreLoadItem( DataStoreItem( itemPath, 1 ) );
1249 }
1250
1252 StatusCode TsDataSvc::resetPreLoad()
1253 {
1254 m_preLoads.erase( m_preLoads.begin(), m_preLoads.end() );
1255 return StatusCode::SUCCESS;
1256 }
1257
1259 StatusCode TsDataSvc::preLoad( int depth, int load_depth, DataObject* pObject )
1260 {
1261 // unused: StatusCode sc = StatusCode::FAILURE;
1262 if ( 0 != pObject && depth++ < load_depth ) {
1263 RegEntry* dir = CAST_REGENTRY( RegEntry*, pObject->registry() );
1264 if ( 0 != dir ) {
1265 for ( RegEntry::Iterator i = dir->begin(); i != dir->end(); i++ ) {
1266 DataObject* pObj = 0;
1267 StatusCode status = retrieveObject( pObject, ( *i )->name(), pObj );
1268 if ( status.isSuccess() && depth < load_depth ) {
1269 preLoad( depth, load_depth, pObj ).ignore();
1270 }
1271 }
1272 }
1273 }
1274 return StatusCode::SUCCESS;
1275 }
1276
1278 StatusCode TsDataSvc::preLoad()
1279 {
1280 DataObject* pObj = 0;
1281 for ( LoadItems::iterator i = m_preLoads.begin(); i != m_preLoads.end(); i++ ) {
1282 StatusCode sc = retrieveObject( ( *i ).path(), pObj );
1283 int load_depth = ( *i ).depth();
1284 if ( sc.isSuccess() && load_depth > 1 ) {
1285 preLoad( 1, load_depth, pObj ).ignore();
1286 }
1287 }
1288 return StatusCode::SUCCESS;
1289 }
1290
1292 StatusCode TsDataSvc::initialize()
1293 {
1294 // Nothing to do: just call base class initialisation
1295 StatusCode sc = Service::initialize();
1296 if ( !sc.isSuccess() ) {
1297 return sc;
1298 }
1299 sc = service( "IncidentSvc", m_incidentSvc, true );
1300 if ( UNLIKELY( !sc.isSuccess() ) ) {
1301 error() << "Failed to access incident service." << endmsg;
1302 }
1303 return sc;
1304 }
1305
1307 StatusCode TsDataSvc::reinitialize()
1308 {
1309 StatusCode sc;
1310 // the finalize part is copied here
1311 setDataLoader( 0 ).ignore();
1312 resetPreLoad().ignore();
1313 clearStore().ignore();
1314 if ( m_incidentSvc ) {
1315 m_incidentSvc->release();
1316 m_incidentSvc = 0;
1317 }
1318 // re-initialize the base class
1319 sc = Service::reinitialize();
1320 if ( UNLIKELY( !sc.isSuccess() ) ) {
1321 error() << "Unable to reinitialize base class" << endmsg;
1322 return sc;
1323 }
1324 // the initialize part is copied here
1325 sc = service( "IncidentSvc", m_incidentSvc, true );
1326 if ( UNLIKELY( !sc.isSuccess() ) ) {
1327 error() << "Failed to access incident service." << endmsg;
1328 return sc;
1329 }
1330 // return
1331 return StatusCode::SUCCESS;
1332 }
1333
1335 StatusCode TsDataSvc::finalize()
1336 {
1337 // Nothing to do: just call base class initialisation
1338 setDataLoader( 0 ).ignore();
1339 resetPreLoad().ignore();
1340 clearStore().ignore();
1341 if ( m_incidentSvc ) {
1342 m_incidentSvc->release();
1343 m_incidentSvc = 0;
1344 }
1345 return Service::finalize();
1346 }
1347
1349 CLID TsDataSvc::rootCLID() const { return ( (CLID)m_rootCLID ); }
1350
1352 const std::string& TsDataSvc::rootName() const { return ( m_rootName ); }
1353
1355 DataObject* TsDataSvc::createDefaultObject() const { return new DataObject(); }
1356
1360 IConversionSvc* TsDataSvc::getDataLoader( IRegistry* /* pReg */ ) { return m_dataLoader; }
1361
1363 TsDataSvc::~TsDataSvc()
1364 {
1365 setDataLoader( 0 ).ignore();
1366 resetPreLoad().ignore();
1367 clearStore().ignore();
1368 }
TsDataSvc::unregisterAddress
StatusCode unregisterAddress(const std::string &fullPath) override
IDataManagerSvc: Unregister object address from the data store.
Definition: TsDataSvc.cpp:363
UNLIKELY
#define UNLIKELY(x)
Definition: Kernel.h:128
TsDataSvc::retrieveObject
StatusCode retrieveObject(IRegistry *pDirectory, const std::string &path, DataObject *&pObject) override
Retrieve object from data store.
Definition: TsDataSvc.cpp:868
Service::initialize
StatusCode initialize() override
Definition: Service.cpp:64
StatusCode::SUCCESS
Definition: StatusCode.h:31
DataSvcHelpers::RegistryEntry::findLeaf
RegistryEntry * findLeaf(boost::string_ref path) const
Find identified leaf in this registry node.
Definition: RegistryEntry.h:94
std::copy
T copy(T...args)
GaudiException
Define general base for Gaudi exception.
Definition: GaudiException.h:22
TsDataSvc::unlinkObject
StatusCode unlinkObject(IRegistry *from, const std::string &objPath) override
Remove a link to another object.
Definition: TsDataSvc.cpp:1152
DataSvcHelpers::RegistryEntry::object
DataObject * object() const override
Retrive object behind the link.
Definition: RegistryEntry.h:122
Service::name
const std::string & name() const override
Retrieve name of the service.
Definition: Service.cpp:289
IConverter::createObj
virtual StatusCode createObj(IOpaqueAddress *pAddress, DataObject *&refpObject)=0
Create the transient representation of an object.
GaudiPython.HistoUtils.path
path
Definition: HistoUtils.py:895
SEPARATOR
constexpr char SEPARATOR
Definition: RegistryEntry.cpp:40
StatusCode::FAILURE
Definition: StatusCode.h:31
TsDataSvc::setRoot
StatusCode setRoot(std::string root_name, DataObject *pRootObj) override
Initialize data store for new event by giving new event path and root object.
Definition: TsDataSvc.cpp:170
Service::finalize
StatusCode finalize() override
Definition: Service.cpp:174
IConversionSvc
Definition: IConversionSvc.h:37
TsDataSvc::addPreLoadItem
StatusCode addPreLoadItem(const DataStoreItem &item) override
Add an item to the preload list.
Definition: TsDataSvc.cpp:1220
System::typeinfoName
GAUDI_API const std::string typeinfoName(const std::type_info &)
Get platform independent information about the class type.
Definition: System.cpp:329
TsDataSvc::traverseTree
StatusCode traverseTree(IDataStoreAgent *pAgent) override
IDataManagerSvc: Analyze by traversing all data objects in the data store.
Definition: TsDataSvc.cpp:157
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:75
TsDataSvc::updateObject
StatusCode updateObject(IRegistry *pDirectory) override
Update object identified by its directory entry.
Definition: TsDataSvc.cpp:996
GaudiPython.Bindings.SUCCESS
SUCCESS
Definition: Bindings.py:56
TsDataSvc::m_accessName
Gaudi::Property< std::string > m_accessName
Definition: TsDataSvc.h:81
DataSvcHelpers::RegistryEntry::add
virtual long add(const std::string &name, DataObject *pObject, bool is_soft=false)
Add entry to data store.
Definition: RegistryEntry.cpp:207
std::string::rfind
T rfind(T...args)
TsDataSvc::m_rootCLID
Gaudi::Property< CLID > m_rootCLID
Definition: TsDataSvc.h:70
DataSvcHelpers::RegistryEntry::traverseTree
virtual long traverseTree(IDataStoreAgent *pAgent, int level=0)
traverse data tree
Definition: RegistryEntry.cpp:300
CommonMessagingBase::verbose
MsgStream & verbose() const
shortcut for the method msgStream(MSG::VERBOSE)
Definition: CommonMessaging.h:123
IConverter::setDataProvider
virtual StatusCode setDataProvider(IDataProviderSvc *pService)=0
Set Data provider service.
TsDataSvc::~TsDataSvc
~TsDataSvc() override
Standard Destructor.
Definition: TsDataSvc.cpp:1363
DataObject::setRegistry
void setRegistry(IRegistry *pRegistry)
Set pointer to Registry.
Definition: DataObject.h:70
DataSvcHelpers::RegistryEntry::release
unsigned long release() override
IInterface implementation: Reference the object.
Definition: RegistryEntry.cpp:68
IRegistry::name
virtual const name_type & name() const =0
Name of the directory (or key)
TsDataSvc::initialize
StatusCode initialize() override
Service initialization.
Definition: TsDataSvc.cpp:1292
TsDataSvc::removePreLoadItem
StatusCode removePreLoadItem(const DataStoreItem &item) override
Remove an item from the preload list.
Definition: TsDataSvc.cpp:1236
std::vector::end
T end(T...args)
TsDataSvc::getDataLoader
virtual IConversionSvc * getDataLoader(IRegistry *pReg)
Retrieve customizable data loader according to registry entry to be retrieved.
Definition: TsDataSvc.cpp:1360
DataSvcHelpers::RegistryEntry::remove
virtual long remove(const std::string &name)
Remove an entry from the store.
Definition: RegistryEntry.cpp:154
DataSvcHelpers::RegistryEntry::leaves
const Store & leaves() const
Access the leaves of the object.
Definition: RegistryEntry.h:130
TsDataSvc::m_dataLoader
IConversionSvc * m_dataLoader
Pointer to data loader service.
Definition: TsDataSvc.h:66
TsDataSvc::setDataLoader
StatusCode setDataLoader(IConversionSvc *svc, IDataProviderSvc *dpsvc=nullptr) override
IDataManagerSvc: IDataManagerSvc: Pass a default data loader to the service and optionally a data pro...
Definition: TsDataSvc.cpp:219
IDataProviderSvc
Data provider interface definition.
Definition: IDataProviderSvc.h:45
std::remove
T remove(T...args)
DataSvcHelpers::RegistryEntry::setAddress
void setAddress(IOpaqueAddress *pAddress) override
Set/Update Opaque address.
Definition: RegistryEntry.cpp:117
DataStoreItem
Description of the DataStoreItem class.
Definition: DataStoreItem.h:17
DataObject::registry
IRegistry * registry() const
Get pointer to Registry.
Definition: DataObject.h:72
IConverter::updateObj
virtual StatusCode updateObj(IOpaqueAddress *pAddress, DataObject *refpObject)=0
Update the transient object from the other representation.
TsDataSvc::resetPreLoad
StatusCode resetPreLoad() override
Clear the preload list.
Definition: TsDataSvc.cpp:1252
DataSvcHelpers::RegistryEntry::parentEntry
virtual RegistryEntry * parentEntry()
Pointer to parent registry entry.
Definition: RegistryEntry.h:92
std::string
STL class.
VERMSG
#define VERMSG
Definition: TsDataSvc.cpp:73
DataSvcHelpers::RegistryEntry::isSoft
virtual bool isSoft() const
Is the link soft or hard.
Definition: RegistryEntry.h:128
TsDataSvc::linkObject
StatusCode linkObject(IRegistry *from, const std::string &objPath, DataObject *to) override
Add a link to another object.
Definition: TsDataSvc.cpp:1075
std::vector::push_back
T push_back(T...args)
CommonMessagingBase::error
MsgStream & error() const
shortcut for the method msgStream(MSG::ERROR)
Definition: CommonMessaging.h:111
xtoa.h
SvcFactory.h
DataObject::addRef
virtual unsigned long addRef()
Add reference to object.
Definition: DataObject.cpp:59
IIncidentSvc::fireIncident
virtual void fireIncident(const Incident &incident)=0
Fire an Incident.
DataSvcHelpers::RegistryEntry::setObject
void setObject(DataObject *obj)
Set/Update object address.
Definition: RegistryEntry.cpp:128
TsDataSvc::preLoad
StatusCode preLoad() override
load all preload items of the list
Definition: TsDataSvc.cpp:1278
TsDataSvc::traverseSubTree
StatusCode traverseSubTree(const std::string &sub_tree_path, IDataStoreAgent *pAgent) override
IDataManagerSvc: Analyze by traversing all data objects below the sub tree identified by its full pat...
Definition: TsDataSvc.cpp:131
TsDataSvc::m_incidentSvc
IIncidentSvc * m_incidentSvc
Pointer to incident service.
Definition: TsDataSvc.h:68
IRegistry::identifier
virtual const id_type & identifier() const =0
Full identifier (or key)
ON_VERBOSE
#define ON_VERBOSE
Definition: TsDataSvc.cpp:70
std::exception::what
T what(T...args)
DataSvcHelpers::RegistryEntry::begin
virtual Iterator begin() const
Return starting point for container iteration.
Definition: RegistryEntry.h:136
IIncidentSvc.h
TsDataSvc::m_root
DataSvcHelpers::RegistryEntry * m_root
Pointer to root entry.
Definition: TsDataSvc.h:86
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:28
std::ostringstream
STL class.
GaudiException.h
TsDataSvc::m_preLoads
LoadItems m_preLoads
Items to be pre-loaded.
Definition: TsDataSvc.h:84
IConverter::updateObjRefs
virtual StatusCode updateObjRefs(IOpaqueAddress *pAddress, DataObject *pObject)=0
Update the references of an updated transient object.
RegEntry
DataSvcHelpers::RegistryEntry RegEntry
Definition: TsDataSvc.cpp:67
std::vector::erase
T erase(T...args)
DataSvcHelpers::RegistryEntry::setDataSvc
void setDataSvc(IDataProviderSvc *s)
Set the transient data store.
Definition: RegistryEntry.h:90
TsDataSvc::rootName
const std::string & rootName() const override
IDataManagerSvc: Accessor for root event name.
Definition: TsDataSvc.cpp:1352
TsDataSvc::m_enableAccessHdlr
Gaudi::Property< bool > m_enableAccessHdlr
Definition: TsDataSvc.h:79
TsDataSvc::reinitialize
StatusCode reinitialize() override
Service initialization.
Definition: TsDataSvc.cpp:1307
std::ostringstream::str
T str(T...args)
TsDataSvc::objectLeaves
StatusCode objectLeaves(const DataObject *pObject, std::vector< IRegistry * > &refLeaves) override
IDataManagerSvc: Explore the object store: retrieve all leaves attached to the object.
Definition: TsDataSvc.cpp:255
IRegistry
The IRegistry represents the entry door to the environment any data object residing in a transient da...
Definition: IRegistry.h:22
DataSvcHelpers::RegistryEntry::isEmpty
virtual bool isEmpty() const
Simple check if the Container is empty.
Definition: RegistryEntry.h:134
Service::reinitialize
StatusCode reinitialize() override
Definition: Service.cpp:250
CLID
unsigned int CLID
Class ID definition.
Definition: ClassID.h:8
DataSvcHelpers::RegistryEntry::Iterator
Store::const_iterator Iterator
Iterator definition.
Definition: RegistryEntry.h:47
TsDataSvc::handleDataFault
DataObject * handleDataFault(IRegistry *pReg, const std::string &path="")
Invoke data fault handling if enabled.
Definition: TsDataSvc.cpp:651
std::exception
STL class.
std::move
T move(T...args)
IRegistry::object
virtual DataObject * object() const =0
Retrieve object behind the link.
IOpaqueAddress.h
RegistryEntry.h
DataSvcHelpers::RegistryEntry
Definition of an entry in the transient data store.
Definition: RegistryEntry.h:36
DataObject::release
virtual unsigned long release()
release reference to object
Definition: DataObject.cpp:51
GaudiPython.Bindings.DataObject
DataObject
Definition: Bindings.py:55
std::string::find
T find(T...args)
std::string::length
T length(T...args)
TsDataSvc::createDefaultObject
virtual DataObject * createDefaultObject() const
Create default objects in case forced creation of leaves is requested.
Definition: TsDataSvc.cpp:1355
IConverter::fillObjRefs
virtual StatusCode fillObjRefs(IOpaqueAddress *pAddress, DataObject *pObject)=0
Resolve the references of the created transient object.
std::vector< IRegistry * >
TsDataSvc::registerObject
StatusCode registerObject(const std::string &fullPath, DataObject *pObject) override
Register object with the data store.
Definition: TsDataSvc.cpp:430
TsDataSvc::clearSubTree
StatusCode clearSubTree(const std::string &sub_tree_path) override
IDataManagerSvc: Remove all data objects below the sub tree identified by its full path name...
Definition: TsDataSvc.cpp:78
IInterface::release
virtual unsigned long release()=0
Release Interface instance.
TsDataSvc::finalize
StatusCode finalize() override
Service initialization.
Definition: TsDataSvc.cpp:1335
DataSvcHelpers::RegistryEntry::parent
virtual IRegistry * parent() const
Pointer to parent directory entry.
Definition: RegistryEntry.h:126
IDataStoreAgent
Generic data agent interface.
Definition: IDataStoreAgent.h:16
IConversionSvc.h
TsDataSvc::registerAddress
StatusCode registerAddress(const std::string &fullPath, IOpaqueAddress *pAddress) override
IDataManagerSvc: Register object address with the data store.
Definition: TsDataSvc.cpp:283
std::vector::begin
T begin(T...args)
TsDataSvc::i_setRoot
virtual StatusCode i_setRoot(std::string root_name, DataObject *pRootObj)
Initialize data store for new event by giving new event path and root object.
Definition: TsDataSvc.cpp:181
DataObject::name
const std::string & name() const
Retreive DataObject name. It is the name when registered in the store.
Definition: DataObject.cpp:68
TsDataSvc::checkRoot
bool checkRoot()
Check if root path is valid.
Definition: TsDataSvc.h:335
IInterface::addRef
virtual unsigned long addRef()=0
Increment the reference count of Interface instance.
std::string::substr
T substr(T...args)
TsDataSvc::m_forceLeaves
Gaudi::Property< bool > m_forceLeaves
Definition: TsDataSvc.h:72
Service::service
StatusCode service(const std::string &name, const T *&psvc, bool createIf=true) const
Access a service by name, creating it if it doesn&#39;t already exist.
Definition: Service.h:85
DataSvcHelpers::RegistryEntry::identifier
const std::string & identifier() const override
Full identifier (or key)
Definition: RegistryEntry.h:118
TsDataSvc::clearStore
StatusCode clearStore() override
IDataManagerSvc: Remove all data objects in the data store.
Definition: TsDataSvc.cpp:118
DataIncident
Data service incident class.
TsDataSvc::unregisterObject
StatusCode unregisterObject(const std::string &fullPath) override
Unregister object from the data store.
Definition: TsDataSvc.cpp:548
IOpaqueAddress
Opaque address interface definition.
Definition: IOpaqueAddress.h:23
StatusCode::ignore
void ignore() const
Definition: StatusCode.h:109
TsDataSvc::rootCLID
CLID rootCLID() const override
IDataManagerSvc: Accessor for root event CLID.
Definition: TsDataSvc.cpp:1349
DataIncident.h
IRegistry::address
virtual IOpaqueAddress * address() const =0
Retrieve opaque storage address.
TsDataSvc::m_inhibitPathes
Gaudi::Property< std::vector< std::string > > m_inhibitPathes
Definition: TsDataSvc.h:73
DataObject
A DataObject is the base class of any identifiable object on any data store.
Definition: DataObject.h:29
TsDataSvc.h
IConverter.h
STD_LOCK_GUARD_MACRO
#define STD_LOCK_GUARD_MACRO
Definition: TsDataSvc.cpp:46
CAST_REGENTRY
#define CAST_REGENTRY(x, y)
Definition: TsDataSvc.cpp:65
TsDataSvc::loadObject
virtual StatusCode loadObject(IRegistry *pNode)
Invoke Persistency service to create transient object from its persistent representation.
Definition: TsDataSvc.cpp:684
TsDataSvc::findObject
StatusCode findObject(const std::string &fullPath, DataObject *&pObject) override
Find object identified by its full path in the data store.
Definition: TsDataSvc.cpp:938
TsDataSvc::objectParent
StatusCode objectParent(const DataObject *pObject, IRegistry *&refpParent) override
IDataManagerSvc: Explore the object store: retrieve the object&#39;s parent.
Definition: TsDataSvc.cpp:231
DataSvcHelpers::RegistryEntry::find
virtual IRegistry * find(const IRegistry *obj) const
Try to find an object identified by its pointer.
Definition: RegistryEntry.h:140
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209
DataSvcHelpers::RegistryEntry::end
virtual Iterator end() const
Return end elemtn if the container.
Definition: RegistryEntry.h:138
TsDataSvc::retrieveEntry
StatusCode retrieveEntry(DataSvcHelpers::RegistryEntry *pNode, const std::string &path, DataSvcHelpers::RegistryEntry *&pEntry)
Retrieve registry entry from store.
Definition: TsDataSvc.cpp:773
TsDataSvc::m_enableFaultHdlr
Gaudi::Property< bool > m_enableFaultHdlr
Definition: TsDataSvc.h:75
TsDataSvc::m_faultName
Gaudi::Property< std::string > m_faultName
Definition: TsDataSvc.h:77
DataObject.h
TsDataSvc::m_rootName
Gaudi::Property< std::string > m_rootName
Definition: TsDataSvc.h:71
DataSvcHelpers::RegistryEntry::makeHard
void makeHard(DataObject *pObject)
Initialize link as hard link.
Definition: RegistryEntry.cpp:101