| The Gaudi Framework v30r0 (c919700c)

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

- File List
- File Members

HiveWhiteBoard.cpp
Go to the documentation of this file.
1 //====================================================================
2 // WhiteBoard (Concurrent Event Data Store)
3 //--------------------------------------------------------------------
4 //
5 //====================================================================
6 // Include files
7 #include "GaudiKernel/DataObjID.h"
8 #include "GaudiKernel/DataObject.h"
9 #include "GaudiKernel/DataSvc.h"
10 #include "GaudiKernel/MsgStream.h"
11 #include "GaudiKernel/Service.h"
12 #include "GaudiKernel/SmartIF.h"
13 #include "GaudiKernel/SvcFactory.h"
14 #include "GaudiKernel/TypeNameString.h"
15 #include "Rtypes.h"
16 #include "ThreadLocalStorage.h"
17 #include "tbb/mutex.h"
18 #include "tbb/recursive_mutex.h"
19 #include <utility>
20
21 // Interfaces
22 #include "GaudiKernel/IAddressCreator.h"
23 #include "GaudiKernel/IConversionSvc.h"
24 #include "GaudiKernel/IDataManagerSvc.h"
25 #include "GaudiKernel/IDataProviderSvc.h"
26 #include "GaudiKernel/IDataStoreAgent.h"
27 #include "GaudiKernel/IHiveWhiteBoard.h"
28 #include "GaudiKernel/IOpaqueAddress.h"
29 #include "GaudiKernel/IRegistry.h"
30 #include "GaudiKernel/ISvcLocator.h"
31 #include "GaudiKernel/ISvcManager.h"
32
33 namespace
34 {
35 struct Partition final {
36 SmartIF<IDataProviderSvc> dataProvider;
37 SmartIF<IDataManagerSvc> dataManager;
38 DataObjIDColl newDataObjects;
39 int eventNumber = -1;
40
41 // allow acces 'by type' -- used in fwd
42 template <typename T>
43 T* get();
44 };
45 template <>
46 IDataProviderSvc* Partition::get<IDataProviderSvc>()
47 {
48 return dataProvider.get();
49 }
50 template <>
51 IDataManagerSvc* Partition::get<IDataManagerSvc>()
52 {
53 return dataManager.get();
54 }
55
56 template <typename T, typename Mutex = tbb::recursive_mutex>
57 class Synced
58 {
59 T m_obj;
60 mutable Mutex m_mtx;
61
62 public:
63 template <typename F>
64 auto with_lock( F&& f ) -> decltype( auto )
65 {
66 typename Mutex::scoped_lock lock;
67 lock.acquire( m_mtx );
68 return f( m_obj );
69 }
70 template <typename F>
71 auto with_lock( F&& f ) const -> decltype( auto )
72 {
73 typename Mutex::scoped_lock lock;
74 lock.acquire( m_mtx );
75 return f( m_obj );
76 }
77 };
78 // transform an f(T) into an f(Synced<T>)
79 template <typename Fun>
80 auto with_lock( Fun&& f )
81 {
82 return [f = std::forward<Fun>( f )]( auto& p )->decltype( auto ) { return p.with_lock( f ); };
83 }
84 // call f(T) for each element in a container of Synced<T>
85 template <typename ContainerOfSynced, typename Fun>
86 void for_( ContainerOfSynced& c, Fun&& f )
87 {
88 std::for_each( begin( c ), end( c ), with_lock( std::forward<Fun>( f ) ) );
89 }
90
91 class DataAgent : virtual public IDataStoreAgent
92 {
93 DataObjIDColl& m_dataObjects;
94
95 public:
96 DataAgent( DataObjIDColl& objs ) : m_dataObjects( objs ) {}
97 bool analyse( IRegistry* pReg, int ) override
98 {
99 if ( !pReg->object() ) return false;
100 m_dataObjects.insert( DataObjID( pReg->identifier() ) );
101 return true;
102 }
103 };
104 }
105
106 TTHREAD_TLS( Synced<Partition>* ) s_current = nullptr;
107
108 namespace
109 {
110 namespace detail
111 {
112 template <typename lambda>
113 struct arg_helper : public arg_helper<decltype( &lambda::operator() )> {
114 };
115 template <typename T, typename Ret, typename Arg>
116 struct arg_helper<Ret ( T::* )( Arg ) const> {
117 using type = Arg;
118 };
119
120 // given a unary lambda whose argument is of type Arg_t,
121 // argument_t<lambda> will be equal to Arg_t
122 template <typename lambda>
123 using argument_t = typename arg_helper<lambda>::type;
124 }
125
126 template <typename Fun>
127 StatusCode fwd( Fun f )
128 {
129 if ( !s_current ) return IDataProviderSvc::INVALID_ROOT;
130 return s_current->with_lock( [&]( Partition& p ) {
131 auto* svc = p.get<std::decay_t<detail::argument_t<Fun>>>();
132 return svc ? f( *svc ) : static_cast<StatusCode>( IDataProviderSvc::INVALID_ROOT );
133 } );
134 }
135 }
136
149 class HiveWhiteBoard : public extends<Service, IDataProviderSvc, IDataManagerSvc, IHiveWhiteBoard>
150 {
151 protected:
152 Gaudi::Property<CLID> m_rootCLID{this, "RootCLID", 110 /*CLID_Event*/, "CLID of root entry"};
153 Gaudi::Property<std::string> m_rootName{this, "RootName", "/Event", "name of root entry"};
154 Gaudi::Property<std::string> m_loader{this, "DataLoader", "EventPersistencySvc", ""};
155 Gaudi::Property<int> m_slots{this, "EventSlots", 1, "number of event slots"};
156 Gaudi::Property<bool> m_forceLeaves{this, "ForceLeaves", false, "force creation of default leaves on registerObject"};
157 Gaudi::Property<bool> m_enableFaultHdlr{this, "EnableFaultHandler", false,
158 "enable incidents on data creation requests"};
159
161 IConversionSvc* m_dataLoader = nullptr;
163 IAddressCreator* m_addrCreator = nullptr;
165 std::vector<Synced<Partition>> m_partitions;
167 std::atomic_int m_freeSlots{0};
168
169 public:
171 using extends::extends;
172
174 ~HiveWhiteBoard() override
175 {
176 setDataLoader( 0 ).ignore();
177 resetPreLoad().ignore();
178 clearStore().ignore();
179 for_( m_partitions, []( Partition& p ) {
180 p.dataManager->release();
181 p.dataProvider->release();
182 } );
183 m_partitions.clear();
184 }
185
187 unsigned int freeSlots() override { return m_freeSlots.load(); };
188
190 CLID rootCLID() const override { return (CLID)m_rootCLID; }
192 const std::string& rootName() const override { return m_rootName; }
193
195 StatusCode registerAddress( boost::string_ref path, IOpaqueAddress* pAddr ) override
196 {
197 return fwd( [&]( IDataManagerSvc& p ) { return p.registerAddress( path, pAddr ); } );
198 }
200 StatusCode registerAddress( DataObject* parent, boost::string_ref path, IOpaqueAddress* pAddr ) override
201 {
202 return fwd( [&]( IDataManagerSvc& p ) { return p.registerAddress( parent, path, pAddr ); } );
203 }
205 StatusCode registerAddress( IRegistry* parent, boost::string_ref path, IOpaqueAddress* pAdd ) override
206 {
207 return fwd( [&]( IDataManagerSvc& p ) { return p.registerAddress( parent, path, pAdd ); } );
208 }
210 StatusCode unregisterAddress( boost::string_ref path ) override
211 {
212 return fwd( [&]( IDataManagerSvc& p ) { return p.unregisterAddress( path ); } );
213 }
215 StatusCode unregisterAddress( DataObject* pParent, boost::string_ref path ) override
216 {
217 return fwd( [&]( IDataManagerSvc& p ) { return p.unregisterAddress( pParent, path ); } );
218 }
220 StatusCode unregisterAddress( IRegistry* pParent, boost::string_ref path ) override
221 {
222 return fwd( [&]( IDataManagerSvc& p ) { return p.unregisterAddress( pParent, path ); } );
223 }
225 StatusCode objectLeaves( const DataObject* pObject, std::vector<IRegistry*>& leaves ) override
226 {
227 return fwd( [&]( IDataManagerSvc& p ) { return p.objectLeaves( pObject, leaves ); } );
228 }
230 StatusCode objectLeaves( const IRegistry* pObject, std::vector<IRegistry*>& leaves ) override
231 {
232 return fwd( [&]( IDataManagerSvc& p ) { return p.objectLeaves( pObject, leaves ); } );
233 }
235 StatusCode objectParent( const DataObject* pObject, IRegistry*& refpParent ) override
236 {
237 return fwd( [&]( IDataManagerSvc& p ) { return p.objectParent( pObject, refpParent ); } );
238 }
240 StatusCode objectParent( const IRegistry* pObject, IRegistry*& refpParent ) override
241 {
242 return fwd( [&]( IDataManagerSvc& p ) { return p.objectParent( pObject, refpParent ); } );
243 }
245 StatusCode clearSubTree( boost::string_ref path ) override
246 {
247 return fwd( [&]( IDataManagerSvc& p ) { return p.clearSubTree( path ); } );
248 }
250 StatusCode clearSubTree( DataObject* pObject ) override
251 {
252 return fwd( [&]( IDataManagerSvc& p ) { return p.clearSubTree( pObject ); } );
253 }
255 StatusCode clearStore() override
256 {
257 for_( m_partitions, []( Partition& p ) { p.dataManager->clearStore().ignore(); } );
258 return StatusCode::SUCCESS;
259 }
260
262 StatusCode traverseSubTree( boost::string_ref path, IDataStoreAgent* pAgent ) override
263 {
264 return fwd( [&]( IDataManagerSvc& p ) { return p.traverseSubTree( path, pAgent ); } );
265 }
267 StatusCode traverseSubTree( DataObject* pObject, IDataStoreAgent* pAgent ) override
268 {
269 return fwd( [&]( IDataManagerSvc& p ) { return p.traverseSubTree( pObject, pAgent ); } );
270 }
272 StatusCode traverseTree( IDataStoreAgent* pAgent ) override
273 {
274 return fwd( [&]( IDataManagerSvc& p ) { return p.traverseTree( pAgent ); } );
275 }
278 StatusCode setRoot( std::string path, DataObject* pObj ) override
279 {
280 return fwd(
281 [ pObj, path = std::move( path ) ]( IDataManagerSvc & p ) { return p.setRoot( std::move( path ), pObj ); } );
282 }
283
286 StatusCode setRoot( std::string path, IOpaqueAddress* pAddr ) override
287 {
288 return fwd(
289 [ pAddr, path = std::move( path ) ]( IDataManagerSvc & p ) { return p.setRoot( std::move( path ), pAddr ); } );
290 }
291
296 StatusCode setDataLoader( IConversionSvc* pDataLoader,
297 IDataProviderSvc* dpsvc __attribute__( ( unused ) ) = nullptr ) override
298 {
299 if ( pDataLoader ) pDataLoader->addRef();
300 if ( m_dataLoader ) m_dataLoader->release();
301 if ( pDataLoader ) pDataLoader->setDataProvider( this );
302 m_dataLoader = pDataLoader;
303 for_( m_partitions, [&]( Partition& p ) { p.dataManager->setDataLoader( m_dataLoader, this ).ignore(); } );
304 return SUCCESS;
305 }
307 StatusCode addPreLoadItem( const DataStoreItem& item ) override
308 {
309 for_( m_partitions, [&]( Partition& p ) { p.dataProvider->addPreLoadItem( item ); } );
310 return StatusCode::SUCCESS;
311 }
313 StatusCode addPreLoadItem( std::string item ) override
314 {
315 for_( m_partitions, [&]( Partition& p ) { p.dataProvider->addPreLoadItem( item ); } );
316 return StatusCode::SUCCESS;
317 }
319 StatusCode removePreLoadItem( const DataStoreItem& item ) override
320 {
321 for_( m_partitions, [&]( Partition& p ) { p.dataProvider->removePreLoadItem( item ); } );
322 return StatusCode::SUCCESS;
323 }
325 StatusCode removePreLoadItem( std::string item ) override
326 {
327 for_( m_partitions, [&]( Partition& p ) { p.dataProvider->removePreLoadItem( item ); } );
328 return StatusCode::SUCCESS;
329 }
331 StatusCode resetPreLoad() override
332 {
333 for_( m_partitions, [&]( Partition& p ) { p.dataProvider->resetPreLoad(); } );
334 return StatusCode::SUCCESS;
335 }
337 StatusCode preLoad() override
338 {
339 return s_current->with_lock( []( Partition& p ) {
340 StatusCode sc = p.dataProvider->preLoad();
341 DataAgent da( p.newDataObjects );
342 p.dataManager->traverseTree( &da );
343 return sc;
344 } );
345 }
347 StatusCode registerObject( boost::string_ref path, DataObject* pObj ) override
348 {
349 return s_current->with_lock( [&]( Partition& p ) {
350 StatusCode sc = p.dataProvider->registerObject( path, pObj );
351 if ( sc.isSuccess() ) {
352 p.newDataObjects.insert( DataObjID( std::string{path.data(), path.size()} ) );
353 }
354 return sc;
355 } );
356 }
358 StatusCode registerObject( boost::string_ref parent, boost::string_ref obj, DataObject* pObj ) override
359 {
360 return fwd( [&]( IDataProviderSvc& p ) { return p.registerObject( parent, obj, pObj ); } );
361 }
363 StatusCode registerObject( boost::string_ref parent, int item, DataObject* pObj ) override
364 {
365 return fwd( [&]( IDataProviderSvc& p ) { return p.registerObject( parent, item, pObj ); } );
366 }
368 StatusCode registerObject( DataObject* parent, boost::string_ref obj, DataObject* pObj ) override
369 {
370 return fwd( [&]( IDataProviderSvc& p ) { return p.registerObject( parent, obj, pObj ); } );
371 }
373 StatusCode registerObject( DataObject* parent, int obj, DataObject* pObj ) override
374 {
375 return fwd( [&]( IDataProviderSvc& p ) { return p.registerObject( parent, obj, pObj ); } );
376 }
378 StatusCode unregisterObject( boost::string_ref path ) override
379 {
380 return fwd( [&]( IDataProviderSvc& p ) { return p.unregisterObject( path ); } );
381 }
383 StatusCode unregisterObject( boost::string_ref parent, boost::string_ref obj ) override
384 {
385 return fwd( [&]( IDataProviderSvc& p ) { return p.unregisterObject( parent, obj ); } );
386 }
388 StatusCode unregisterObject( boost::string_ref parent, int obj ) override
389 {
390 return fwd( [&]( IDataProviderSvc& p ) { return p.unregisterObject( parent, obj ); } );
391 }
393 StatusCode unregisterObject( DataObject* pObj ) override
394 {
395 return fwd( [&]( IDataProviderSvc& p ) { return p.unregisterObject( pObj ); } );
396 }
398 StatusCode unregisterObject( DataObject* pObj, boost::string_ref path ) override
399 {
400 return fwd( [&]( IDataProviderSvc& p ) { return p.unregisterObject( pObj, path ); } );
401 }
403 StatusCode unregisterObject( DataObject* pObj, int item ) override
404 {
405 return fwd( [&]( IDataProviderSvc& p ) { return p.unregisterObject( pObj, item ); } );
406 }
408 StatusCode retrieveObject( IRegistry* parent, boost::string_ref path, DataObject*& pObj ) override
409 {
410 return fwd( [&]( IDataProviderSvc& p ) { return p.retrieveObject( parent, path, pObj ); } );
411 }
413 StatusCode retrieveObject( boost::string_ref path, DataObject*& pObj ) override
414 {
415 return fwd( [&]( IDataProviderSvc& p ) { return p.retrieveObject( path, pObj ); } );
416 }
418 StatusCode retrieveObject( boost::string_ref parent, boost::string_ref path, DataObject*& pObj ) override
419 {
420 return fwd( [&]( IDataProviderSvc& p ) { return p.retrieveObject( parent, path, pObj ); } );
421 }
423 StatusCode retrieveObject( boost::string_ref parent, int item, DataObject*& pObj ) override
424 {
425 return fwd( [&]( IDataProviderSvc& p ) { return p.retrieveObject( parent, item, pObj ); } );
426 }
428 StatusCode retrieveObject( DataObject* parent, boost::string_ref path, DataObject*& pObj ) override
429 {
430 return fwd( [&]( IDataProviderSvc& p ) { return p.retrieveObject( parent, path, pObj ); } );
431 }
433 StatusCode retrieveObject( DataObject* parent, int item, DataObject*& pObj ) override
434 {
435 return fwd( [&]( IDataProviderSvc& p ) { return p.retrieveObject( parent, item, pObj ); } );
436 }
438 StatusCode findObject( boost::string_ref path, DataObject*& pObj ) override
439 {
440 return fwd( [&]( IDataProviderSvc& p ) { return p.retrieveObject( path, pObj ); } );
441 }
443 StatusCode findObject( IRegistry* parent, boost::string_ref path, DataObject*& pObj ) override
444 {
445 return fwd( [&]( IDataProviderSvc& p ) { return p.retrieveObject( parent, path, pObj ); } );
446 }
448 StatusCode findObject( boost::string_ref parent, boost::string_ref path, DataObject*& pObj ) override
449 {
450 return fwd( [&]( IDataProviderSvc& p ) { return p.retrieveObject( parent, path, pObj ); } );
451 }
453 StatusCode findObject( boost::string_ref parent, int item, DataObject*& pObject ) override
454 {
455 return fwd( [&]( IDataProviderSvc& p ) { return p.findObject( parent, item, pObject ); } );
456 }
458 StatusCode findObject( DataObject* parent, boost::string_ref path, DataObject*& pObject ) override
459 {
460 return fwd( [&]( IDataProviderSvc& p ) { return p.findObject( parent, path, pObject ); } );
461 }
463 StatusCode findObject( DataObject* parent, int item, DataObject*& pObject ) override
464 {
465 return fwd( [&]( IDataProviderSvc& p ) { return p.findObject( parent, item, pObject ); } );
466 }
468 StatusCode linkObject( IRegistry* from, boost::string_ref objPath, DataObject* to ) override
469 {
470 return fwd( [&]( IDataProviderSvc& p ) { return p.linkObject( from, objPath, to ); } );
471 }
473 StatusCode linkObject( boost::string_ref from, boost::string_ref objPath, DataObject* to ) override
474 {
475 return fwd( [&]( IDataProviderSvc& p ) { return p.linkObject( from, objPath, to ); } );
476 }
478 StatusCode linkObject( DataObject* from, boost::string_ref objPath, DataObject* to ) override
479 {
480 return fwd( [&]( IDataProviderSvc& p ) { return p.linkObject( from, objPath, to ); } );
481 }
483 StatusCode linkObject( boost::string_ref fullPath, DataObject* to ) override
484 {
485 return fwd( [&]( IDataProviderSvc& p ) { return p.linkObject( fullPath, to ); } );
486 }
488 StatusCode unlinkObject( IRegistry* from, boost::string_ref objPath ) override
489 {
490 return fwd( [&]( IDataProviderSvc& p ) { return p.unlinkObject( from, objPath ); } );
491 }
493 StatusCode unlinkObject( boost::string_ref from, boost::string_ref objPath ) override
494 {
495 return fwd( [&]( IDataProviderSvc& p ) { return p.unlinkObject( from, objPath ); } );
496 }
498 StatusCode unlinkObject( DataObject* from, boost::string_ref objPath ) override
499 {
500 return fwd( [&]( IDataProviderSvc& p ) { return p.unlinkObject( from, objPath ); } );
501 }
503 StatusCode unlinkObject( boost::string_ref path ) override
504 {
505 return fwd( [&]( IDataProviderSvc& p ) { return p.unlinkObject( path ); } );
506 }
508 StatusCode updateObject( IRegistry* pDirectory ) override
509 {
510 return fwd( [&]( IDataProviderSvc& p ) { return p.updateObject( pDirectory ); } );
511 }
513 StatusCode updateObject( boost::string_ref path ) override
514 {
515 return fwd( [&]( IDataProviderSvc& p ) { return p.updateObject( path ); } );
516 }
518 StatusCode updateObject( DataObject* pObj ) override
519 {
520 return fwd( [&]( IDataProviderSvc& p ) { return p.updateObject( pObj ); } );
521 }
523 StatusCode updateObject( boost::string_ref parent, boost::string_ref updatePath ) override
524 {
525 return fwd( [&]( IDataProviderSvc& p ) { return p.updateObject( parent, updatePath ); } );
526 }
528 StatusCode updateObject( DataObject* parent, boost::string_ref updatePath ) override
529 {
530 return fwd( [&]( IDataProviderSvc& p ) { return p.updateObject( parent, updatePath ); } );
531 }
532
533 //
534 //---IHiveWhiteBard implemenation--------------------------------------------------
535 //
536
538 StatusCode clearStore( size_t partition ) override
539 {
540 return m_partitions[partition].with_lock( []( Partition& p ) { return p.dataManager->clearStore(); } );
541 }
542
544 StatusCode selectStore( size_t partition ) override
545 {
546 s_current = &m_partitions[partition];
547 return StatusCode::SUCCESS;
548 }
549
551 StatusCode setNumberOfStores( size_t slots ) override
552 {
553 if ( (int)slots != m_slots && FSMState() == Gaudi::StateMachine::INITIALIZED ) {
554 warning() << "Too late to change the number of slots!" << endmsg;
555 return StatusCode::FAILURE;
556 }
557 m_slots = slots;
558 return StatusCode::SUCCESS;
559 }
560
562 size_t getNumberOfStores() const override { return m_slots; }
563
565 DataObjIDColl getNewDataObjects() override
566 {
567 return s_current->with_lock( [&]( Partition& p ) { return std::exchange( p.newDataObjects, {} ); } );
568 }
569
571 void addNewDataObjects( DataObjIDColl& products ) override
572 {
573 s_current->with_lock( [&]( Partition& p ) { p.newDataObjects.insert( begin( products ), end( products ) ); } );
574 }
575
577 bool exists( const DataObjID& id ) override
578 {
579 DataObject* pObject{nullptr};
580 return findObject( id.fullKey(), pObject ).isSuccess();
581 }
582
584 size_t allocateStore( int evtnumber ) override
585 {
586 enum class Status { NotFound, Allocated, StillActive };
587 auto attempt_to_allocate = with_lock( [evtnumber, this]( Partition& p ) {
588 if ( p.eventNumber == evtnumber ) return Status::StillActive;
589 if ( p.eventNumber == -1 ) {
590 this->m_freeSlots--;
591 p.eventNumber = evtnumber;
592 return Status::Allocated;
593 }
594 return Status::NotFound;
595 } );
596
597 size_t index = 0;
598 for ( auto& p : m_partitions ) {
599 switch ( attempt_to_allocate( p ) ) {
600 case Status::StillActive:
601 error() << "Attempt to allocate a store partition for an event that is still active" << endmsg;
602 return std::string::npos;
603 case Status::Allocated:
604 // info() << "Got allocated slot..." << index << endmsg;
605 return index;
606 default:
607 ++index;
608 }
609 };
610 return std::string::npos;
611 }
612
614 StatusCode freeStore( size_t partition ) override
615 {
616 m_partitions[partition].with_lock( []( Partition& p ) { p.eventNumber = -1; } );
617 // info() << "Freed slot..." << partition << endmsg;
618 m_freeSlots++;
619 return StatusCode::SUCCESS;
620 }
621
623 size_t getPartitionNumber( int eventnumber ) const override
624 {
625 auto i = std::find_if( begin( m_partitions ), end( m_partitions ),
626 with_lock( [eventnumber]( const Partition& p ) { return p.eventNumber == eventnumber; } ) );
627 return i != end( m_partitions ) ? std::distance( begin( m_partitions ), i ) : std::string::npos;
628 }
629
630 StatusCode attachServices()
631 {
632 StatusCode sc = service( m_loader, m_addrCreator, true );
633 if ( !sc.isSuccess() ) {
634 error() << "Failed to retrieve data loader "
635 << "\"" << m_loader << "\"" << endmsg;
636 return sc;
637 }
638 IConversionSvc* dataLoader = nullptr;
639 sc = service( m_loader, dataLoader, true );
640 if ( !sc.isSuccess() ) {
641 error() << MSG::ERROR << "Failed to retrieve data loader "
642 << "\"" << m_loader << "\"" << endmsg;
643 return sc;
644 }
645 sc = setDataLoader( dataLoader );
646 dataLoader->release();
647 if ( !sc.isSuccess() ) {
648 error() << MSG::ERROR << "Failed to set data loader "
649 << "\"" << m_loader << "\"" << endmsg;
650 return sc;
651 }
652 return sc;
653 }
654
655 StatusCode detachServices()
656 {
657 if ( m_addrCreator ) m_addrCreator->release();
658 if ( m_dataLoader ) m_dataLoader->release();
659 m_addrCreator = nullptr;
660 m_dataLoader = nullptr;
661 return StatusCode::SUCCESS;
662 }
663
664 //
665 //---IService implemenation---------------------------------------------------------
666 //
667
669 StatusCode initialize() override
670 {
671 StatusCode sc = Service::initialize();
672 if ( !sc.isSuccess() ) {
673 error() << "Unable to initialize base class" << endmsg;
674 return sc;
675 }
676 if ( m_slots < 1 ) {
677 error() << "Invalid number of slots (" << m_slots << ")" << endmsg;
678 return StatusCode::FAILURE;
679 }
680
681 m_partitions = std::vector<Synced<Partition>>( m_slots );
682 for ( int i = 0; i < m_slots; i++ ) {
683 DataSvc* svc = new DataSvc( name() + "_" + std::to_string( i ), serviceLocator() );
684 // Percolate properties
685 svc->setProperty( m_rootCLID ).ignore();
686 svc->setProperty( m_rootName ).ignore();
687 svc->setProperty( m_forceLeaves ).ignore();
688 svc->setProperty( m_enableFaultHdlr ).ignore();
689 // make sure that CommonMessaging is initialized
690 svc->setProperty( m_outputLevel ).ignore();
691
692 sc = svc->initialize();
693 if ( !sc.isSuccess() ) {
694 error() << "Failed to instantiate DataSvc as store partition" << endmsg;
695 return sc;
696 }
697 m_partitions[i].with_lock( [&]( Partition& p ) {
698 p.dataProvider = svc;
699 p.dataManager = svc;
700 } );
701 }
702 selectStore( 0 ).ignore();
703 m_freeSlots.store( m_slots );
704 return attachServices();
705 }
706
708 StatusCode reinitialize() override
709 {
710 StatusCode sc = Service::reinitialize();
711 if ( !sc.isSuccess() ) {
712 error() << "Unable to reinitialize base class" << endmsg;
713 return sc;
714 }
715 detachServices();
716 sc = attachServices();
717 if ( !sc.isSuccess() ) {
718 error() << "Failed to attach necessary services." << endmsg;
719 return sc;
720 }
721 return StatusCode::SUCCESS;
722 }
723
725 StatusCode finalize() override
726 {
727 setDataLoader( 0 ).ignore();
728 clearStore().ignore();
729 return Service::finalize();
730 }
731 };
732
733 // Instantiation of a static factory class used by clients to create
734 // instances of this service
735 DECLARE_SERVICE_FACTORY( HiveWhiteBoard )
IDataManagerSvc::traverseTree
virtual StatusCode traverseTree(IDataStoreAgent *pAgent)=0
Analyse by traversing all data objects in the data store.
HiveWhiteBoard::updateObject
StatusCode updateObject(IRegistry *pDirectory) override
Update object identified by its directory entry.
Definition: HiveWhiteBoard.cpp:508
StatusCode::SUCCESS
Definition: StatusCode.h:29
Service::initialize
StatusCode initialize() override
Definition: Service.cpp:64
Gaudi::StateMachine::INITIALIZED
Definition: StateMachine.h:17
HiveWhiteBoard::unregisterObject
StatusCode unregisterObject(DataObject *pObj) override
Unregister object from the data store.
Definition: HiveWhiteBoard.cpp:393
SmartIF< IDataProviderSvc >
__attribute__
#define __attribute__(x)
Definition: System.cpp:89
HiveWhiteBoard::allocateStore
size_t allocateStore(int evtnumber) override
Allocate a store partition for a given event number.
Definition: HiveWhiteBoard.cpp:584
IDataManagerSvc::objectLeaves
virtual StatusCode objectLeaves(const DataObject *pObject, std::vector< IRegistry * > &refLeaves)=0
Explore the object store: retrieve all leaves attached to the object The object is identified by its ...
HiveWhiteBoard::findObject
StatusCode findObject(boost::string_ref parent, int item, DataObject *&pObject) override
Find object in the data store.
Definition: HiveWhiteBoard.cpp:453
IDataProviderSvc::unlinkObject
virtual StatusCode unlinkObject(IRegistry *from, boost::string_ref objPath)=0
Remove a link to another object.
std::distance
T distance(T...args)
gaudirun.c
c
Definition: gaudirun.py:407
HiveWhiteBoard::updateObject
StatusCode updateObject(boost::string_ref parent, boost::string_ref updatePath) override
Update object.
Definition: HiveWhiteBoard.cpp:523
HiveWhiteBoard::setDataLoader
StatusCode setDataLoader(IConversionSvc *pDataLoader, IDataProviderSvc *dpsvc __attribute__((unused))=nullptr) override
IDataManagerSvc: Pass a default data loader to the service.
Definition: HiveWhiteBoard.cpp:296
GaudiPython.HistoUtils.path
path
Definition: HistoUtils.py:895
gaudiComponentHelp.name
name
Definition: gaudiComponentHelp.py:32
Service::finalize
StatusCode finalize() override
Definition: Service.cpp:174
IConversionSvc
Definition: IConversionSvc.h:37
HiveWhiteBoard::linkObject
StatusCode linkObject(boost::string_ref fullPath, DataObject *to) override
Add a link to another object.
Definition: HiveWhiteBoard.cpp:483
Gaudi::Property
Implementation of property with value of concrete type.
Definition: Property.h:319
PropertyHolder::setProperty
StatusCode setProperty(const Gaudi::Details::PropertyBase &p) override
set the property form another property
Definition: PropertyHolder.h:208
DataObjID
Definition: DataObjID.h:37
MsgStream.h
HiveWhiteBoard::freeStore
StatusCode freeStore(size_t partition) override
Free a store partition.
Definition: HiveWhiteBoard.cpp:614
HiveWhiteBoard::getNewDataObjects
DataObjIDColl getNewDataObjects() override
Get the list of new DataObjects in the current store.
Definition: HiveWhiteBoard.cpp:565
IDataManagerSvc
Definition: IDataManagerSvc.h:46
IDataProviderSvc::INVALID_ROOT
Invalid root path object cannot be retrieved or stored.
Definition: IDataProviderSvc.h:496
HiveWhiteBoard::unlinkObject
StatusCode unlinkObject(IRegistry *from, boost::string_ref objPath) override
Remove a link to another object.
Definition: HiveWhiteBoard.cpp:488
HiveWhiteBoard::getPartitionNumber
size_t getPartitionNumber(int eventnumber) const override
Get the partition number corresponding to a given event.
Definition: HiveWhiteBoard.cpp:623
HiveWhiteBoard::clearStore
StatusCode clearStore(size_t partition) override
Remove all data objects in one &#39;slot&#39; of the data store.
Definition: HiveWhiteBoard.cpp:538
HiveWhiteBoard::registerObject
StatusCode registerObject(boost::string_ref path, DataObject *pObj) override
Register object with the data store. (The most common one is the only monitored one for the time bein...
Definition: HiveWhiteBoard.cpp:347
IDataProviderSvc::findObject
virtual StatusCode findObject(IRegistry *pDirectory, boost::string_ref path, DataObject *&pObject)=0
Find object identified by its directory entry.
HiveWhiteBoard::retrieveObject
StatusCode retrieveObject(boost::string_ref path, DataObject *&pObj) override
Retrieve object identified by its full path from the data store.
Definition: HiveWhiteBoard.cpp:413
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:50
HiveWhiteBoard::registerAddress
StatusCode registerAddress(boost::string_ref path, IOpaqueAddress *pAddr) override
IDataManagerSvc: Register object address with the data store.
Definition: HiveWhiteBoard.cpp:195
GaudiPython.Bindings.SUCCESS
SUCCESS
Definition: Bindings.py:56
IDataManagerSvc::setRoot
virtual StatusCode setRoot(std::string root_name, DataObject *pObject)=0
Initialize data store for new event by giving new event path.
HiveWhiteBoard::retrieveObject
StatusCode retrieveObject(DataObject *parent, boost::string_ref path, DataObject *&pObj) override
Retrieve object from data store.
Definition: HiveWhiteBoard.cpp:428
HiveWhiteBoard::findObject
StatusCode findObject(DataObject *parent, int item, DataObject *&pObject) override
Find object in the data store.
Definition: HiveWhiteBoard.cpp:463
std::to_string
T to_string(T...args)
IAddressCreator
IAddressCreator interface definition.
Definition: IAddressCreator.h:28
HiveWhiteBoard::unlinkObject
StatusCode unlinkObject(boost::string_ref path) override
Remove a link to another object.
Definition: HiveWhiteBoard.cpp:503
IConverter::setDataProvider
virtual StatusCode setDataProvider(IDataProviderSvc *pService)=0
Set Data provider service.
HiveWhiteBoard::findObject
StatusCode findObject(IRegistry *parent, boost::string_ref path, DataObject *&pObj) override
Find object identified by its full path in the data store.
Definition: HiveWhiteBoard.cpp:443
HiveWhiteBoard::unregisterAddress
StatusCode unregisterAddress(boost::string_ref path) override
IDataManagerSvc: Unregister object address from the data store.
Definition: HiveWhiteBoard.cpp:210
HiveWhiteBoard::resetPreLoad
StatusCode resetPreLoad() override
Clear the preload list.
Definition: HiveWhiteBoard.cpp:331
HiveWhiteBoard::finalize
StatusCode finalize() override
Service initialisation.
Definition: HiveWhiteBoard.cpp:725
HiveWhiteBoard::clearSubTree
StatusCode clearSubTree(DataObject *pObject) override
Remove all data objects below the sub tree identified.
Definition: HiveWhiteBoard.cpp:250
HiveWhiteBoard::getNumberOfStores
size_t getNumberOfStores() const override
Get the number of event slots (copies of DataSvc objects).
Definition: HiveWhiteBoard.cpp:562
HiveWhiteBoard::objectParent
StatusCode objectParent(const IRegistry *pObject, IRegistry *&refpParent) override
IDataManagerSvc: Explore the object store: retrieve the object&#39;s parent.
Definition: HiveWhiteBoard.cpp:240
HiveWhiteBoard::linkObject
StatusCode linkObject(DataObject *from, boost::string_ref objPath, DataObject *to) override
Add a link to another object.
Definition: HiveWhiteBoard.cpp:478
HiveWhiteBoard::addPreLoadItem
StatusCode addPreLoadItem(const DataStoreItem &item) override
Add an item to the preload list.
Definition: HiveWhiteBoard.cpp:307
HiveWhiteBoard::updateObject
StatusCode updateObject(DataObject *pObj) override
Update object.
Definition: HiveWhiteBoard.cpp:518
HiveWhiteBoard::m_partitions
std::vector< Synced< Partition > > m_partitions
Datastore partitions.
Definition: HiveWhiteBoard.cpp:165
IDataProviderSvc
Data provider interface definition.
Definition: IDataProviderSvc.h:46
HiveWhiteBoard::preLoad
StatusCode preLoad() override
load all preload items of the list
Definition: HiveWhiteBoard.cpp:337
DataStoreItem
Description of the DataStoreItem class.
Definition: DataStoreItem.h:17
HiveWhiteBoard::unregisterObject
StatusCode unregisterObject(DataObject *pObj, int item) override
Unregister object from the data store.
Definition: HiveWhiteBoard.cpp:403
ISvcManager.h
HiveWhiteBoard::unlinkObject
StatusCode unlinkObject(DataObject *from, boost::string_ref objPath) override
Remove a link to another object.
Definition: HiveWhiteBoard.cpp:498
IDataManagerSvc::objectParent
virtual StatusCode objectParent(const DataObject *pObject, IRegistry *&refpParent)=0
IDataManagerSvc: Explore the object store: retrieve the object&#39;s parent.
HiveWhiteBoard::clearStore
StatusCode clearStore() override
IDataManagerSvc: Remove all data objects in the data store.
Definition: HiveWhiteBoard.cpp:255
HiveWhiteBoard::unregisterObject
StatusCode unregisterObject(boost::string_ref parent, boost::string_ref obj) override
Unregister object from the data store.
Definition: HiveWhiteBoard.cpp:383
HiveWhiteBoard::selectStore
StatusCode selectStore(size_t partition) override
Activate a partition object. The identifies the partition uniquely.
Definition: HiveWhiteBoard.cpp:544
begin
auto begin(reverse_wrapper< T > &w)
Definition: reverse.h:58
std::string
STL class.
IDataProviderSvc::linkObject
virtual StatusCode linkObject(IRegistry *from, boost::string_ref objPath, DataObject *toObj)=0
Add a link to another object.
Service.h
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...
DataSvc.h
SvcFactory.h
std::string::data
T data(T...args)
IDataManagerSvc.h
IDataProviderSvc.h
HiveWhiteBoard::detachServices
StatusCode detachServices()
Definition: HiveWhiteBoard.cpp:655
detail
TupleObj.h GaudiAlg/TupleObj.h namespace with few technical implementations.
HiveWhiteBoard::unregisterAddress
StatusCode unregisterAddress(IRegistry *pParent, boost::string_ref path) override
IDataManagerSvc: Unregister object address from the data store.
Definition: HiveWhiteBoard.cpp:220
IRegistry::identifier
virtual const id_type & identifier() const =0
Full identifier (or key)
HiveWhiteBoard::objectLeaves
StatusCode objectLeaves(const IRegistry *pObject, std::vector< IRegistry * > &leaves) override
Explore the object store: retrieve all leaves attached to the object.
Definition: HiveWhiteBoard.cpp:230
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
IDataProviderSvc::updateObject
virtual StatusCode updateObject(IRegistry *pDirectory)=0
Update object identified by its directory entry.
HiveWhiteBoard::removePreLoadItem
StatusCode removePreLoadItem(std::string item) override
Add an item to the preload list.
Definition: HiveWhiteBoard.cpp:325
gaudirun.type
type
Definition: gaudirun.py:133
SmartIF.h
HiveWhiteBoard::addPreLoadItem
StatusCode addPreLoadItem(std::string item) override
Add an item to the preload list.
Definition: HiveWhiteBoard.cpp:313
HiveWhiteBoard::freeSlots
unsigned int freeSlots() override
Get free slots number.
Definition: HiveWhiteBoard.cpp:187
HiveWhiteBoard::retrieveObject
StatusCode retrieveObject(boost::string_ref parent, int item, DataObject *&pObj) override
Retrieve object from data store.
Definition: HiveWhiteBoard.cpp:423
HiveWhiteBoard::linkObject
StatusCode linkObject(IRegistry *from, boost::string_ref objPath, DataObject *to) override
Add a link to another object.
Definition: HiveWhiteBoard.cpp:468
HiveWhiteBoard::unregisterObject
StatusCode unregisterObject(boost::string_ref path) override
Unregister object from the data store.
Definition: HiveWhiteBoard.cpp:378
std::lock
T lock(T...args)
HiveWhiteBoard::removePreLoadItem
StatusCode removePreLoadItem(const DataStoreItem &item) override
Remove an item from the preload list.
Definition: HiveWhiteBoard.cpp:319
IRegistry.h
IRegistry
The IRegistry represents the entry door to the environment any data object residing in a transient da...
Definition: IRegistry.h:22
end
auto end(reverse_wrapper< T > &w)
Definition: reverse.h:64
std::unordered_set< DataObjID, DataObjID_Hasher >
Service::reinitialize
StatusCode reinitialize() override
Definition: Service.cpp:250
HiveWhiteBoard::traverseSubTree
StatusCode traverseSubTree(boost::string_ref path, IDataStoreAgent *pAgent) override
Analyze by traversing all data objects below the sub tree.
Definition: HiveWhiteBoard.cpp:262
DECLARE_SERVICE_FACTORY
#define DECLARE_SERVICE_FACTORY(x)
Definition: Service.h:211
IDataProviderSvc::retrieveObject
virtual StatusCode retrieveObject(IRegistry *pDirectory, boost::string_ref path, DataObject *&pObject)=0
Retrieve object identified by its directory entry.
CLID
unsigned int CLID
Class ID definition.
Definition: ClassID.h:8
HiveWhiteBoard::registerObject
StatusCode registerObject(DataObject *parent, int obj, DataObject *pObj) override
Register object with the data store.
Definition: HiveWhiteBoard.cpp:373
IDataManagerSvc::clearSubTree
virtual StatusCode clearSubTree(boost::string_ref sub_path)=0
Remove all data objects below the sub tree identified by its full path name.
std::vector::clear
T clear(T...args)
HiveWhiteBoard::clearSubTree
StatusCode clearSubTree(boost::string_ref path) override
Remove all data objects below the sub tree identified.
Definition: HiveWhiteBoard.cpp:245
EventStatus::Status
Status
Definition: IAlgExecStateSvc.h:67
IDataStoreAgent.h
std::move
T move(T...args)
HiveWhiteBoard
Data service base class.
Definition: HiveWhiteBoard.cpp:149
HiveWhiteBoard::unlinkObject
StatusCode unlinkObject(boost::string_ref from, boost::string_ref objPath) override
Remove a link to another object.
Definition: HiveWhiteBoard.cpp:493
IRegistry::object
virtual DataObject * object() const =0
Retrieve object behind the link.
TTHREAD_TLS
TTHREAD_TLS(Synced< Partition > *) s_current
HiveWhiteBoard::findObject
StatusCode findObject(boost::string_ref parent, boost::string_ref path, DataObject *&pObj) override
Find object in the data store.
Definition: HiveWhiteBoard.cpp:448
DataObjID.h
IOpaqueAddress.h
HiveWhiteBoard::attachServices
StatusCode attachServices()
Definition: HiveWhiteBoard.cpp:630
HiveWhiteBoard::traverseSubTree
StatusCode traverseSubTree(DataObject *pObject, IDataStoreAgent *pAgent) override
IDataManagerSvc: Analyze by traversing all data objects below the sub tree.
Definition: HiveWhiteBoard.cpp:267
std::unordered_set::insert
T insert(T...args)
IDataManagerSvc::unregisterAddress
virtual StatusCode unregisterAddress(boost::string_ref fullPath)=0
Unregister object address from the data store.
std::find_if
T find_if(T...args)
IDataProviderSvc::unregisterObject
virtual StatusCode unregisterObject(boost::string_ref fullPath)=0
Unregister object from the data store.
HiveWhiteBoard::registerObject
StatusCode registerObject(boost::string_ref parent, int item, DataObject *pObj) override
Register object with the data store.
Definition: HiveWhiteBoard.cpp:363
HiveWhiteBoard::objectParent
StatusCode objectParent(const DataObject *pObject, IRegistry *&refpParent) override
IDataManagerSvc: Explore the object store: retrieve the object&#39;s parent.
Definition: HiveWhiteBoard.cpp:235
HiveWhiteBoard::setRoot
StatusCode setRoot(std::string path, IOpaqueAddress *pAddr) override
Initialize data store for new event by giving new event path and address of root object.
Definition: HiveWhiteBoard.cpp:286
std::vector
STL class.
IInterface::release
virtual unsigned long release()=0
Release Interface instance.
IDataStoreAgent
Generic data agent interface.
Definition: IDataStoreAgent.h:16
IAddressCreator.h
IConversionSvc.h
IHiveWhiteBoard.h
extends
Base class used to extend a class implementing other interfaces.
Definition: extends.h:10
DataSvc::initialize
StatusCode initialize() override
Service initialization.
Definition: DataSvc.cpp:1086
HiveWhiteBoard::unregisterObject
StatusCode unregisterObject(DataObject *pObj, boost::string_ref path) override
Unregister object from the data store.
Definition: HiveWhiteBoard.cpp:398
IDataProviderSvc::registerObject
virtual StatusCode registerObject(boost::string_ref fullPath, DataObject *pObject)=0
Register object with the data store.
HiveWhiteBoard::setRoot
StatusCode setRoot(std::string path, DataObject *pObj) override
Initialize data store for new event by giving new event path and root object.
Definition: HiveWhiteBoard.cpp:278
HiveWhiteBoard::rootCLID
CLID rootCLID() const override
IDataManagerSvc: Accessor for root event CLID.
Definition: HiveWhiteBoard.cpp:190
DataSvc
Data service base class.
Definition: DataSvc.h:44
IDataManagerSvc::registerAddress
virtual StatusCode registerAddress(boost::string_ref fullPath, IOpaqueAddress *pAddress)=0
Register object address with the data store.
HiveWhiteBoard::registerAddress
StatusCode registerAddress(IRegistry *parent, boost::string_ref path, IOpaqueAddress *pAdd) override
IDataManagerSvc: Register object address with the data store.
Definition: HiveWhiteBoard.cpp:205
TypeNameString.h
HiveWhiteBoard::retrieveObject
StatusCode retrieveObject(DataObject *parent, int item, DataObject *&pObj) override
Retrieve object from data store.
Definition: HiveWhiteBoard.cpp:433
MSG::ERROR
Definition: IMessageSvc.h:16
IInterface::addRef
virtual unsigned long addRef()=0
Increment the reference count of Interface instance.
HiveWhiteBoard::unregisterObject
StatusCode unregisterObject(boost::string_ref parent, int obj) override
Unregister object from the data store.
Definition: HiveWhiteBoard.cpp:388
HiveWhiteBoard::objectLeaves
StatusCode objectLeaves(const DataObject *pObject, std::vector< IRegistry * > &leaves) override
Explore the object store: retrieve all leaves attached to the object.
Definition: HiveWhiteBoard.cpp:225
HiveWhiteBoard::registerObject
StatusCode registerObject(DataObject *parent, boost::string_ref obj, DataObject *pObj) override
Register object with the data store.
Definition: HiveWhiteBoard.cpp:368
HiveWhiteBoard::initialize
StatusCode initialize() override
Service initialisation.
Definition: HiveWhiteBoard.cpp:669
HiveWhiteBoard::linkObject
StatusCode linkObject(boost::string_ref from, boost::string_ref objPath, DataObject *to) override
Add a link to another object.
Definition: HiveWhiteBoard.cpp:473
HiveWhiteBoard::updateObject
StatusCode updateObject(boost::string_ref path) override
Update object.
Definition: HiveWhiteBoard.cpp:513
StatusCode::FAILURE
Definition: StatusCode.h:29
HiveWhiteBoard::traverseTree
StatusCode traverseTree(IDataStoreAgent *pAgent) override
IDataManagerSvc: Analyze by traversing all data objects in the data store.
Definition: HiveWhiteBoard.cpp:272
HiveWhiteBoard::addNewDataObjects
void addNewDataObjects(DataObjIDColl &products) override
add to the list of new DataObjects in the current store.
Definition: HiveWhiteBoard.cpp:571
HiveWhiteBoard::findObject
StatusCode findObject(boost::string_ref path, DataObject *&pObj) override
Find object identified by its full path in the data store.
Definition: HiveWhiteBoard.cpp:438
IOpaqueAddress
Opaque address interface definition.
Definition: IOpaqueAddress.h:23
StatusCode::ignore
void ignore() const
Definition: StatusCode.h:84
HiveWhiteBoard::findObject
StatusCode findObject(DataObject *parent, boost::string_ref path, DataObject *&pObject) override
Find object in the data store.
Definition: HiveWhiteBoard.cpp:458
HiveWhiteBoard::registerObject
StatusCode registerObject(boost::string_ref parent, boost::string_ref obj, DataObject *pObj) override
Register object with the data store.
Definition: HiveWhiteBoard.cpp:358
HiveWhiteBoard::retrieveObject
StatusCode retrieveObject(boost::string_ref parent, boost::string_ref path, DataObject *&pObj) override
Retrieve object from data store.
Definition: HiveWhiteBoard.cpp:418
std::for_each
T for_each(T...args)
DataObject
A DataObject is the base class of any identifiable object on any data store.
Definition: DataObject.h:30
ISvcLocator.h
HiveWhiteBoard::updateObject
StatusCode updateObject(DataObject *parent, boost::string_ref updatePath) override
Update object.
Definition: HiveWhiteBoard.cpp:528
HiveWhiteBoard::unregisterAddress
StatusCode unregisterAddress(DataObject *pParent, boost::string_ref path) override
IDataManagerSvc: Unregister object address from the data store.
Definition: HiveWhiteBoard.cpp:215
HiveWhiteBoard::exists
bool exists(const DataObjID &id) override
check if a data object exists in the current store
Definition: HiveWhiteBoard.cpp:577
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209
HiveWhiteBoard::rootName
const std::string & rootName() const override
Name for root Event.
Definition: HiveWhiteBoard.cpp:192
HiveWhiteBoard::reinitialize
StatusCode reinitialize() override
Service initialisation.
Definition: HiveWhiteBoard.cpp:708
HiveWhiteBoard::retrieveObject
StatusCode retrieveObject(IRegistry *parent, boost::string_ref path, DataObject *&pObj) override
Retrieve object from data store.
Definition: HiveWhiteBoard.cpp:408
HiveWhiteBoard::setNumberOfStores
StatusCode setNumberOfStores(size_t slots) override
Set the number of event slots (copies of DataSvc objects).
Definition: HiveWhiteBoard.cpp:551
DataObject.h
HiveWhiteBoard::~HiveWhiteBoard
~HiveWhiteBoard() override
Standard Destructor.
Definition: HiveWhiteBoard.cpp:174
HiveWhiteBoard::registerAddress
StatusCode registerAddress(DataObject *parent, boost::string_ref path, IOpaqueAddress *pAddr) override
IDataManagerSvc: Register object address with the data store.
Definition: HiveWhiteBoard.cpp:200