| The Gaudi Framework v30r0 (c919700c)

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

- File List
- File Members

DataObjectHandleBase.cpp
Go to the documentation of this file.
1 #include "GaudiKernel/DataObjectHandleBase.h"
2 #include "GaudiKernel/AlgTool.h"
3 #include "GaudiKernel/Algorithm.h"
4 #include "GaudiKernel/IDataProviderSvc.h"
5 #include "GaudiKernel/SerializeSTL.h"
6 #include "GaudiKernel/ServiceLocatorHelper.h"
7
8 #include <boost/tokenizer.hpp>
9 #include <ostream>
10 #include <sstream>
11 #include <string>
12
13 const DataObjID INVALID_DATAOBJID = DataObjID();
14
15 //---------------------------------------------------------------------------
16 DataObjectHandleBase::DataObjectHandleBase( DataObjectHandleBase&& other )
17 : Gaudi::DataHandle( other )
18 , m_EDS( std::move( other.m_EDS ) )
19 , m_MS( std::move( other.m_MS ) )
20 , m_init( other.m_init )
21 , m_optional( other.m_optional )
22 , m_wasRead( other.m_wasRead )
23 , m_wasWritten( other.m_wasWritten )
24 , m_searchDone( other.m_searchDone )
25 {
26 m_owner->declare( *this );
27 }
28
29 //---------------------------------------------------------------------------
30 DataObjectHandleBase& DataObjectHandleBase::operator=( const DataObjectHandleBase& other )
31 {
32 // avoid modification of searchDone in other while we are copying
33 std::lock_guard<std::mutex> guard( other.m_searchMutex );
34 // FIXME: operator= should not change our owner, only our 'value'
35 Gaudi::DataHandle::operator=( other );
36 m_EDS = other.m_EDS;
37 m_MS = other.m_MS;
38 m_init = other.m_init;
39 m_optional = other.m_optional;
40 m_wasRead = other.m_wasRead;
41 m_wasWritten = other.m_wasWritten;
42 m_searchDone = other.m_searchDone;
43 return *this;
44 }
45
46 //---------------------------------------------------------------------------
47 DataObjectHandleBase::DataObjectHandleBase( const DataObjID& k, Gaudi::DataHandle::Mode a, IDataHandleHolder* owner )
48 : Gaudi::DataHandle( k, a, owner )
49 {
50 m_owner->declare( *this );
51 }
52
53 //---------------------------------------------------------------------------
54
55 DataObjectHandleBase::DataObjectHandleBase( const std::string& k, Gaudi::DataHandle::Mode a, IDataHandleHolder* owner )
56 : DataObjectHandleBase( DataObjID( k ), a, owner )
57 {
58 }
59
60 //---------------------------------------------------------------------------
61 DataObjectHandleBase::~DataObjectHandleBase() { owner()->renounce( *this ); }
62
63 //---------------------------------------------------------------------------
64 DataObject* DataObjectHandleBase::fetch() const
65 {
66 DataObject* p = nullptr;
67 if ( LIKELY( m_searchDone ) ) { // fast path: searchDone, objKey is in its final state
68 m_EDS->retrieveObject( objKey(), p ).ignore();
69 return p;
70 }
71
72 // slow path -- move into seperate function to improve code generation?
73
74 // convenience towards users -- remind them to register
75 // but as m_MS is not yet set, we cannot use a MsgStream...
76 if ( !m_init ) {
77 std::cerr << ( owner() ? owner()->name() : "<UNKNOWN>:" ) << "DataObjectHandle: uninitialized data handle"
78 << std::endl;
79 }
80
81 // as m_searchDone is not true yet, objKey may change... so in this
82 // branch we _first_ grab the mutex, to avoid objKey changing while we use it
83
84 // take a lock to be sure we only execute this once at a time
85 std::lock_guard<std::mutex> guard( m_searchMutex );
86
87 StatusCode sc = m_EDS->retrieveObject( objKey(), p );
88 if ( m_searchDone ) { // another thread has done the search while we were blocked
89 // on the mutex. As a result, nothing left to do but return...
90 sc.ignore();
91 return p;
92 }
93
94 if ( !sc.isSuccess() ) {
95 auto tokens = boost::tokenizer<boost::char_separator<char>>{objKey(), boost::char_separator<char>{":"}};
96 // let's try our alternatives (if any)
97 auto alt = std::find_if( tokens.begin(), tokens.end(),
98 [&]( const std::string& n ) { return m_EDS->retrieveObject( n, p ).isSuccess(); } );
99 if ( alt != tokens.end() ) {
100 MsgStream log( m_MS, owner()->name() + ":DataObjectHandle" );
101 log << MSG::DEBUG << ": could not find \"" << objKey() << "\" -- using alternative source: \"" << *alt
102 << "\" instead" << endmsg;
103 // found something -- set it as default; this is not atomic, but
104 // at least in `fetch` there is no use of `objKey` that races with
105 // this assignment... (but there may be others!)
106 setKey( *alt );
107 }
108 }
109 m_searchDone = true;
110 return p;
111 }
112
113 //---------------------------------------------------------------------------
114
115 std::string DataObjectHandleBase::toString() const { return objKey(); }
116
117 //---------------------------------------------------------------------------
118 std::string DataObjectHandleBase::pythonRepr() const { return "DataObjectHandleBase(\"" + toString() + "\")"; }
119
120 //---------------------------------------------------------------------------
121 void DataObjectHandleBase::fromString( const std::string& s ) { Gaudi::Parsers::parse( *this, s ).ignore(); }
122
123 //---------------------------------------------------------------------------
124
125 bool DataObjectHandleBase::init()
126 {
127
128 assert( !m_init );
129
130 if ( !owner() ) return false;
131
132 setRead( false );
133 setWritten( false );
134
135 Algorithm* algorithm = dynamic_cast<Algorithm*>( owner() );
136 if ( algorithm ) {
137 // Fetch the event Data Service from the algorithm
138 m_EDS = algorithm->evtSvc();
139 m_MS = algorithm->msgSvc();
140 } else {
141 AlgTool* tool = dynamic_cast<AlgTool*>( owner() );
142 if ( tool ) {
143 m_EDS = tool->evtSvc();
144 m_MS = tool->msgSvc();
145 } else {
146 throw GaudiException( "owner is neither AlgTool nor Algorithm", "Invalid Cast", StatusCode::FAILURE );
147 }
148 }
149 m_init = true;
150 return true;
151 }
152
153 //---------------------------------------------------------------------------
154
155 bool DataObjectHandleBase::isValid() const { return fullKey() != INVALID_DATAOBJID; }
156
157 //---------------------------------------------------------------------------
158
159 std::ostream& operator<<( std::ostream& str, const DataObjectHandleBase& d )
160 {
161
162 str << d.fullKey() << " m: " << d.mode();
163 if ( d.owner() ) str << " o: " << d.owner()->name();
164 str << " opt: " << d.isOptional();
165 return str;
166 }
DataObjectHandleBase::setWritten
void setWritten(bool wasWritten=true)
Definition: DataObjectHandleBase.h:66
MsgStream
Definition of the MsgStream class used to transmit messages.
Definition: MsgStream.h:24
DataObjectHandleBase::~DataObjectHandleBase
virtual ~DataObjectHandleBase()
Definition: DataObjectHandleBase.cpp:61
Algorithm.h
GaudiException
Define general base for Gaudi exception.
Definition: GaudiException.h:22
IDataHandleHolder::declare
virtual void declare(Gaudi::DataHandle &)=0
gaudiComponentHelp.name
name
Definition: gaudiComponentHelp.py:32
DataObjectHandleBase::m_wasRead
bool m_wasRead
Definition: DataObjectHandleBase.h:78
DataObjID
Definition: DataObjID.h:37
Gaudi::DataHandle::objKey
virtual const std::string & objKey() const
Definition: DataHandle.h:49
StatusCode::isSuccess
bool isSuccess() const
Test for a status code of SUCCESS.
Definition: StatusCode.h:50
AlgTool.h
Gaudi::DataHandle::mode
virtual Mode mode() const
Definition: DataHandle.h:44
MSG::DEBUG
Definition: IMessageSvc.h:16
std::endl
T endl(T...args)
DataObjectHandleBase::m_EDS
SmartIF< IDataProviderSvc > m_EDS
Definition: DataObjectHandleBase.h:73
std
STL namespace.
DataObjectHandleBase::m_init
bool m_init
Definition: DataObjectHandleBase.h:76
Gaudi::Parsers::parse
StatusCode parse(GaudiUtils::HashMap< K, V > &result, const std::string &input)
Basic parser for the types of HashMap used in DODBasicMapper.
Definition: DODBasicMapper.cpp:13
IDataHandleHolder::renounce
virtual void renounce(Gaudi::DataHandle &)=0
DataObjectHandleBase::setRead
void setRead(bool wasRead=true)
Definition: DataObjectHandleBase.h:65
DataObjectHandleBase::toString
std::string toString() const
Definition: DataObjectHandleBase.cpp:115
Gaudi::DataHandle::setKey
virtual void setKey(const DataObjID &key) const
Definition: DataHandle.h:46
DataObjectHandleBase::m_searchDone
bool m_searchDone
Whether the search part of the fetch method (so dealing with alt names was already executed or not...
Definition: DataObjectHandleBase.h:86
SerializeSTL.h
Provide serialization function (output only) for some common STL classes (vectors, lists, pairs, maps) plus GaudiUtils::Map and GaudiUtils::HashMap.
DataObjectHandleBase::m_optional
bool m_optional
Definition: DataObjectHandleBase.h:77
operator=
PropertyMgr & operator=(const PropertyMgr &)=delete
std::string
STL class.
GaudiPluginService.cpluginsvc.n
n
Definition: cpluginsvc.py:228
DataObjectHandleBase::operator=
DataObjectHandleBase & operator=(const DataObjectHandleBase &)
Definition: DataObjectHandleBase.cpp:30
Gaudi::DataHandle::fullKey
virtual const DataObjID & fullKey() const
Definition: DataHandle.h:50
IDataHandleHolder
Definition: IDataHandleHolder.h:14
IDataProviderSvc.h
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
Gaudi::DataHandle::m_owner
IDataHandleHolder * m_owner
Definition: DataHandle.h:69
INVALID_DATAOBJID
const DataObjID INVALID_DATAOBJID
Definition: DataObjectHandleBase.cpp:13
CommonMessagingBase::msgSvc
const SmartIF< IMessageSvc > & msgSvc() const
The standard message service.
Definition: CommonMessaging.h:75
IDataProviderSvc::retrieveObject
virtual StatusCode retrieveObject(IRegistry *pDirectory, boost::string_ref path, DataObject *&pObject)=0
Retrieve object identified by its directory entry.
DataObjectHandleBase::fromString
void fromString(const std::string &s)
Definition: DataObjectHandleBase.cpp:121
AlgTool::evtSvc
IDataProviderSvc * evtSvc() const
accessor to event service service
Definition: AlgTool.cpp:93
LIKELY
#define LIKELY(x)
Definition: Kernel.h:127
DataObjectHandleBase.h
Algorithm
Base class from which all concrete algorithm classes should be derived.
Definition: Algorithm.h:79
DataObjectHandleBase::isValid
bool isValid() const
Definition: DataObjectHandleBase.cpp:155
std::find_if
T find_if(T...args)
Algorithm::evtSvc
SmartIF< IDataProviderSvc > & evtSvc() const
shortcut for method eventSvc
Definition: Algorithm.h:282
std::lock_guard
DataObjectHandleBase
DataObjectHandleBase GaudiKernel/DataObjectHandleBase.h.
Definition: DataObjectHandleBase.h:25
DataObjectHandleBase::m_searchMutex
std::mutex m_searchMutex
A Mutex protecting the calls to the search part of the fetch method, so that we are sure that we only...
Definition: DataObjectHandleBase.h:92
Gaudi::DataHandle::DataHandle
DataHandle(const DataObjID &k, Mode a=Reader, IDataHandleHolder *owner=nullptr)
Definition: DataHandle.h:33
AlgTool
Base class from which all the concrete tool classes should be derived.
Definition: AlgTool.h:48
gaudirun.s
string s
Definition: gaudirun.py:253
DataObjectHandleBase::pythonRepr
std::string pythonRepr() const override
Definition: DataObjectHandleBase.cpp:118
ServiceLocatorHelper.h
DataObjectHandleBase::fetch
DataObject * fetch() const
Definition: DataObjectHandleBase.cpp:64
DataObjectHandleBase::init
bool init() override
Definition: DataObjectHandleBase.cpp:125
StatusCode::FAILURE
Definition: StatusCode.h:29
StatusCode::ignore
void ignore() const
Definition: StatusCode.h:84
DataObjectHandleBase::m_MS
SmartIF< IMessageSvc > m_MS
Definition: DataObjectHandleBase.h:74
Gaudi::DataHandle::Mode
Mode
Definition: DataHandle.h:31
DataObjectHandleBase::isOptional
bool isOptional() const
Check if the data object declared is optional for the algorithm.
Definition: DataObjectHandleBase.h:55
DataObject
A DataObject is the base class of any identifiable object on any data store.
Definition: DataObject.h:30
std::cerr
DataObjectHandleBase::operator<<
friend std::ostream & operator<<(std::ostream &str, const DataObjectHandleBase &d)
Definition: DataObjectHandleBase.cpp:159
Gaudi
Helper functions to set/get the application return code.
Definition: __init__.py:1
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:209
INamedInterface::name
virtual const std::string & name() const =0
Retrieve the name of the instance.
Gaudi::DataHandle::owner
virtual IDataHandleHolder * owner() const
Definition: DataHandle.h:42
DataObjectHandleBase::DataObjectHandleBase
DataObjectHandleBase(const DataObjID &k, Gaudi::DataHandle::Mode a, IDataHandleHolder *owner)
Definition: DataObjectHandleBase.cpp:47
DataObjectHandleBase::m_wasWritten
bool m_wasWritten
Definition: DataObjectHandleBase.h:79
Gaudi.Configuration.log
log
Definition: Configuration.py:13