| The Gaudi Framework v32r1 (f65d50dc)

Public Types | Public Member Functions | Protected Member Functions | Protected Attributes | Friends | List of all members
DataObjectHandleBase Class Reference

DataObjectHandleBase GaudiKernel/DataObjectHandleBase.h. More...

`#include <GaudiKernel/DataObjectHandleBase.h>`

Inheritance diagram for DataObjectHandleBase:
[legend]
Collaboration diagram for DataObjectHandleBase:
[legend]

## Public Types
using | PropertyType = DataObjectHandleProperty
Public Types inherited from Gaudi::DataHandle
enum | Mode { Reader = 1 << 2, Writer = 1 << 4, Updater = Reader | Writer }

## Public Member Functions
| DataObjectHandleBase (const DataObjID &k, Gaudi::DataHandle::Mode a, IDataHandleHolder *owner)
| DataObjectHandleBase (const std::string &k, Gaudi::DataHandle::Mode a, IDataHandleHolder *owner)
virtual | ~DataObjectHandleBase ()
| DataObjectHandleBase (const DataObjectHandleBase &)=delete
| DataObjectHandleBase (DataObjectHandleBase &&)
DataObjectHandleBase & | operator= (const DataObjectHandleBase &)
template<class OWNER , class K , typename = std::enable_if_t<std::is_base_of_v<IProperty, OWNER>>>
| DataObjectHandleBase (OWNER *owner, Gaudi::DataHandle::Mode m, std::string name, const K &key={}, std::string doc="")
| Autodeclaring constructor with property name, mode, key and documentation. More...
std::string | toString () const
std::string | pythonRepr () const override
void | fromString (const std::string &s)
bool | isOptional () const
| Check if the data object declared is optional for the algorithm. More...
void | setOptional (bool optional=true)
bool | initialized () const
bool | wasRead () const
bool | wasWritten () const
bool | isValid () const
Public Member Functions inherited from Gaudi::DataHandle
| DataHandle (const DataObjID &k, Mode a=Reader, IDataHandleHolder *owner=nullptr)
| DataHandle (const DataObjID &k, const bool &isCond, Mode a=Reader, IDataHandleHolder *owner=nullptr)
virtual | ~DataHandle ()=default
virtual void | setOwner (IDataHandleHolder *o)
virtual IDataHandleHolder * | owner () const
virtual Mode | mode () const
virtual void | setKey (const DataObjID &key) const
virtual void | updateKey (const std::string &key) const
virtual const std::string & | objKey () const
virtual const DataObjID & | fullKey () const
virtual void | reset (bool)
virtual bool | isCondition () const

## Protected Member Functions
void | setRead (bool wasRead=true)
void | setWritten (bool wasWritten=true)
bool | init () override
DataObject * | fetch () const

## Protected Attributes
SmartIF< IDataProviderSvc > | m_EDS
SmartIF< IMessageSvc > | m_MS
bool | m_init = false
bool | m_optional = false
bool | m_wasRead = false
bool | m_wasWritten = false
bool | m_searchDone = false
| Whether the search part of the fetch method (so dealing with alt names was already executed or not. More...
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 call it once. More...
Protected Attributes inherited from Gaudi::DataHandle
DataObjID | m_key = {"NONE"}
| The key of the object behind this DataHandle Although it may look strange to have it mutable, this can actually change in case the object had alternative names, and it should not be visible to the end user, for which the Handle is still the same. More...
IDataHandleHolder * | m_owner = nullptr

## Friends
std::ostream & | operator<< (std::ostream &str, const DataObjectHandleBase &d)

## Detailed Description

DataObjectHandleBase GaudiKernel/DataObjectHandleBase.h.

Base class for handles to Data Objects in the Event Store, to simplify access via Properties.

Author
  Charles Leggett

Date
  2015-09-01

Definition at line 26 of file DataObjectHandleBase.h.

## Member Typedef Documentation

## ◆ PropertyType

using DataObjectHandleBase::PropertyType = DataObjectHandleProperty

Definition at line 53 of file DataObjectHandleBase.h.

## Constructor & Destructor Documentation

## ◆ DataObjectHandleBase() [1/5]

DataObjectHandleBase::DataObjectHandleBase | ( | const DataObjID & | k,
|  | Gaudi::DataHandle::Mode | a,
|  | IDataHandleHolder * | owner
| ) |  |

Definition at line 45 of file DataObjectHandleBase.cpp.

46 : Gaudi::DataHandle( k, a, owner ) {
47 m_owner->declare( *this );
48 }
IDataHandleHolder::declare
virtual void declare(Gaudi::DataHandle &)=0
Gaudi::DataHandle::owner
virtual IDataHandleHolder * owner() const
Definition: DataHandle.h:40
Gaudi::DataHandle::m_owner
IDataHandleHolder * m_owner
Definition: DataHandle.h:66
Gaudi::DataHandle
Definition: DataHandle.h:27

## ◆ DataObjectHandleBase() [2/5]

DataObjectHandleBase::DataObjectHandleBase | ( | const std::string & | k,
|  | Gaudi::DataHandle::Mode | a,
|  | IDataHandleHolder * | owner
| ) |  |

Definition at line 52 of file DataObjectHandleBase.cpp.

53 : DataObjectHandleBase( DataObjID( k ), a, owner ) {}
DataObjID
Definition: DataObjID.h:37
Gaudi::DataHandle::owner
virtual IDataHandleHolder * owner() const
Definition: DataHandle.h:40
DataObjectHandleBase::DataObjectHandleBase
DataObjectHandleBase(const DataObjID &k, Gaudi::DataHandle::Mode a, IDataHandleHolder *owner)
Definition: DataObjectHandleBase.cpp:45

## ◆ ~DataObjectHandleBase()

DataObjectHandleBase::~DataObjectHandleBase | ( |  | ) |
| virtual

Definition at line 56 of file DataObjectHandleBase.cpp.

56 { owner()->renounce( *this ); }
Gaudi::DataHandle::owner
virtual IDataHandleHolder * owner() const
Definition: DataHandle.h:40
IDataHandleHolder::renounce
virtual void renounce(Gaudi::DataHandle &)=0

## ◆ DataObjectHandleBase() [3/5]

DataObjectHandleBase::DataObjectHandleBase | ( | const DataObjectHandleBase & |  | ) |
| delete

## ◆ DataObjectHandleBase() [4/5]

DataObjectHandleBase::DataObjectHandleBase | ( | DataObjectHandleBase && | other | ) |

Definition at line 16 of file DataObjectHandleBase.cpp.

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 m_owner->declare( *this );
26 }
IDataHandleHolder::declare
virtual void declare(Gaudi::DataHandle &)=0
DataObjectHandleBase::m_wasRead
bool m_wasRead
Definition: DataObjectHandleBase.h:79
DataObjectHandleBase::m_EDS
SmartIF< IDataProviderSvc > m_EDS
Definition: DataObjectHandleBase.h:74
DataObjectHandleBase::m_init
bool m_init
Definition: DataObjectHandleBase.h:77
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:87
DataObjectHandleBase::m_optional
bool m_optional
Definition: DataObjectHandleBase.h:78
Gaudi::DataHandle::m_owner
IDataHandleHolder * m_owner
Definition: DataHandle.h:66
Gaudi::DataHandle
Definition: DataHandle.h:27
std::move
T move(T... args)
DataObjectHandleBase::m_MS
SmartIF< IMessageSvc > m_MS
Definition: DataObjectHandleBase.h:75
DataObjectHandleBase::m_wasWritten
bool m_wasWritten
Definition: DataObjectHandleBase.h:80

## ◆ DataObjectHandleBase() [5/5]

template<class OWNER , class K , typename = std::enable_if_t<std::is_base_of_v<IProperty, OWNER>>>

DataObjectHandleBase::DataObjectHandleBase | ( | OWNER * | owner,
|  | Gaudi::DataHandle::Mode | m,
|  | std::string | name,
|  | const K & | key = `{}`,
|  | std::string | doc = `""`
| ) |  |
| inline

Autodeclaring constructor with property name, mode, key and documentation.

Note
  the use std::enable_if is required to avoid ambiguities

Definition at line 40 of file DataObjectHandleBase.h.

40 {},
41 std::string doc = "" )
42 : DataObjectHandleBase( key, m, owner ) {
43 auto p = owner->declareProperty( std::move( name ), *this, std::move( doc ) );
44 p->template setOwnerType<OWNER>();
45 }
gaudiComponentHelp.name
name
Definition: gaudiComponentHelp.py:41
Gaudi::DataHandle::owner
virtual IDataHandleHolder * owner() const
Definition: DataHandle.h:40
std::string
STL class.
Gaudi::Units::m
constexpr double m
Definition: SystemOfUnits.h:92
std::move
T move(T... args)
DataObjectHandleBase::DataObjectHandleBase
DataObjectHandleBase(const DataObjID &k, Gaudi::DataHandle::Mode a, IDataHandleHolder *owner)
Definition: DataObjectHandleBase.cpp:45

## Member Function Documentation

## ◆ fetch()

DataObject * DataObjectHandleBase::fetch | ( |  | ) | const
| protected

Definition at line 59 of file DataObjectHandleBase.cpp.

59 {
60 DataObject* p = nullptr;
61 if ( LIKELY( m_searchDone ) ) { // fast path: searchDone, objKey is in its final state
62 m_EDS->retrieveObject( objKey(), p ).ignore();
63 return p;
64 }
65
66 // slow path -- move into seperate function to improve code generation?
67
68 // convenience towards users -- remind them to register
69 // but as m_MS is not yet set, we cannot use a MsgStream...
70 if ( !m_init ) {
71 std::cerr << ( owner() ? owner()->name() : "<UNKNOWN>:" ) << "DataObjectHandle: uninitialized data handle"
72 << std::endl;
73 }
74
75 // as m_searchDone is not true yet, objKey may change... so in this
76 // branch we _first_ grab the mutex, to avoid objKey changing while we use it
77
78 // take a lock to be sure we only execute this once at a time
79 std::lock_guard<std::mutex> guard( m_searchMutex );
80
81 StatusCode sc = m_EDS->retrieveObject( objKey(), p );
82 if ( m_searchDone ) { // another thread has done the search while we were blocked
83 // on the mutex. As a result, nothing left to do but return...
84 sc.ignore();
85 return p;
86 }
87
88 if ( !sc.isSuccess() ) {
89 auto tokens = boost::tokenizer<boost::char_separator<char>>{objKey(), boost::char_separator<char>{":"}};
90 // let's try our alternatives (if any)
91 auto alt = std::find_if( tokens.begin(), tokens.end(),
92 [&]( const std::string& n ) { return m_EDS->retrieveObject( n, p ).isSuccess(); } );
93 if ( alt != tokens.end() ) {
94 MsgStream log( m_MS, owner()->name() + ":DataObjectHandle" );
95 log << MSG::DEBUG << ": could not find \"" << objKey() << "\" -- using alternative source: \"" << *alt
96 << "\" instead" << endmsg;
97 // found something -- set it as default; this is not atomic, but
98 // at least in `fetch` there is no use of `objKey` that races with
99 // this assignment... (but there may be others!)
100 setKey( *alt );
101 }
102 }
103 m_searchDone = true;
104 return p;
105 }
MsgStream
Definition of the MsgStream class used to transmit messages.
Definition: MsgStream.h:24
gaudiComponentHelp.name
name
Definition: gaudiComponentHelp.py:41
Gaudi::DataHandle::owner
virtual IDataHandleHolder * owner() const
Definition: DataHandle.h:40
MSG::DEBUG
Definition: IMessageSvc.h:15
std::endl
T endl(T... args)
Gaudi::DataHandle::objKey
virtual const std::string & objKey() const
Definition: DataHandle.h:47
DataObjectHandleBase::m_EDS
SmartIF< IDataProviderSvc > m_EDS
Definition: DataObjectHandleBase.h:74
DataObjectHandleBase::m_init
bool m_init
Definition: DataObjectHandleBase.h:77
Gaudi::DataHandle::setKey
virtual void setKey(const DataObjID &key) const
Definition: DataHandle.h:44
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:87
std::string
STL class.
INamedInterface::name
virtual const std::string & name() const =0
Retrieve the name of the instance.
GaudiPluginService.cpluginsvc.n
n
Definition: cpluginsvc.py:210
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:50
StatusCode::isSuccess
bool isSuccess() const
Definition: StatusCode.h:267
LIKELY
#define LIKELY(x)
Definition: Kernel.h:95
std::find_if
T find_if(T... args)
StatusCode::ignore
const StatusCode & ignore() const
Ignore/check StatusCode.
Definition: StatusCode.h:153
IDataProviderSvc::retrieveObject
virtual StatusCode retrieveObject(IRegistry *pDirectory, std::string_view path, DataObject *&pObject)=0
Retrieve object identified by its directory entry.
std::lock_guard
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:93
DataObjectHandleBase::m_MS
SmartIF< IMessageSvc > m_MS
Definition: DataObjectHandleBase.h:75
DataObject
A DataObject is the base class of any identifiable object on any data store.
Definition: DataObject.h:30
std::cerr
endmsg
MsgStream & endmsg(MsgStream &s)
MsgStream Modifier: endmsg. Calls the output method of the MsgStream.
Definition: MsgStream.h:192
Gaudi.Configuration.log
log
Definition: Configuration.py:13

## ◆ fromString()

void DataObjectHandleBase::fromString | ( | const std::string & | s | ) |

Definition at line 129 of file DataObjectHandleBase.cpp.

129 { Gaudi::Parsers::parse( *this, s ).ignore(); }
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:11
StatusCode::ignore
const StatusCode & ignore() const
Ignore/check StatusCode.
Definition: StatusCode.h:153
gaudirun.s
string s
Definition: gaudirun.py:316

## ◆ init()

bool DataObjectHandleBase::init | ( |  | ) |
| override protected virtual

Reimplemented from Gaudi::DataHandle.

Definition at line 133 of file DataObjectHandleBase.cpp.

133 {
134
135 assert( !m_init );
136
137 if ( !owner() ) return false;
138
139 setRead( false );
140 setWritten( false );
141
142 Gaudi::Algorithm* algorithm = dynamic_cast<Gaudi::Algorithm*>( owner() );
143 if ( algorithm ) {
144 // Fetch the event Data Service from the algorithm
145 m_EDS = algorithm->evtSvc();
146 m_MS = algorithm->msgSvc();
147 } else {
148 AlgTool* tool = dynamic_cast<AlgTool*>( owner() );
149 if ( tool ) {
150 m_EDS = tool->evtSvc();
151 m_MS = tool->msgSvc();
152 } else {
153 throw GaudiException( "owner is neither AlgTool nor Gaudi::Algorithm", "Invalid Cast", StatusCode::FAILURE );
154 }
155 }
156 m_init = true;
157 return true;
158 }
DataObjectHandleBase::setWritten
void setWritten(bool wasWritten=true)
Definition: DataObjectHandleBase.h:67
GaudiException
Define general base for Gaudi exception.
Definition: GaudiException.h:21
CommonMessagingBase::msgSvc
const SmartIF< IMessageSvc > & msgSvc() const
The standard message service.
Definition: CommonMessaging.h:68
Gaudi::DataHandle::owner
virtual IDataHandleHolder * owner() const
Definition: DataHandle.h:40
DataObjectHandleBase::m_EDS
SmartIF< IDataProviderSvc > m_EDS
Definition: DataObjectHandleBase.h:74
Gaudi::Algorithm::evtSvc
SmartIF< IDataProviderSvc > & evtSvc() const
shortcut for method eventSvc
Definition: Algorithm.h:265
DataObjectHandleBase::m_init
bool m_init
Definition: DataObjectHandleBase.h:77
DataObjectHandleBase::setRead
void setRead(bool wasRead=true)
Definition: DataObjectHandleBase.h:66
AlgTool
Base class from which all the concrete tool classes should be derived.
Definition: AlgTool.h:47
Gaudi::Algorithm
Base class from which all concrete algorithm classes should be derived.
Definition: Algorithm.h:79
StatusCode::FAILURE
constexpr static const auto FAILURE
Definition: StatusCode.h:86
DataObjectHandleBase::m_MS
SmartIF< IMessageSvc > m_MS
Definition: DataObjectHandleBase.h:75
AlgTool::evtSvc
IDataProviderSvc * evtSvc() const
accessor to event service service
Definition: AlgTool.cpp:88

## ◆ initialized()

bool DataObjectHandleBase::initialized | ( |  | ) | const
| inline

Definition at line 59 of file DataObjectHandleBase.h.

59 { return m_init; }
DataObjectHandleBase::m_init
bool m_init
Definition: DataObjectHandleBase.h:77

## ◆ isOptional()

bool DataObjectHandleBase::isOptional | ( |  | ) | const
| inline

Check if the data object declared is optional for the algorithm.

Definition at line 56 of file DataObjectHandleBase.h.

56 { return m_optional; }
DataObjectHandleBase::m_optional
bool m_optional
Definition: DataObjectHandleBase.h:78

## ◆ isValid()

bool DataObjectHandleBase::isValid | ( |  | ) | const

Definition at line 162 of file DataObjectHandleBase.cpp.

162 { return fullKey() != INVALID_DATAOBJID; }
Gaudi::DataHandle::fullKey
virtual const DataObjID & fullKey() const
Definition: DataHandle.h:48
INVALID_DATAOBJID
const DataObjID INVALID_DATAOBJID
Definition: DataObjectHandleBase.cpp:13

## ◆ operator=()

DataObjectHandleBase & DataObjectHandleBase::operator= | ( | const DataObjectHandleBase & | other | ) |

Definition at line 29 of file DataObjectHandleBase.cpp.

29 {
30 // avoid modification of searchDone in other while we are copying
31 std::lock_guard<std::mutex> guard( other.m_searchMutex );
32 // FIXME: operator= should not change our owner, only our 'value'
33 Gaudi::DataHandle::operator=( other );
34 m_EDS = other.m_EDS;
35 m_MS = other.m_MS;
36 m_init = other.m_init;
37 m_optional = other.m_optional;
38 m_wasRead = other.m_wasRead;
39 m_wasWritten = other.m_wasWritten;
40 m_searchDone = other.m_searchDone;
41 return *this;
42 }
DataObjectHandleBase::m_wasRead
bool m_wasRead
Definition: DataObjectHandleBase.h:79
DataObjectHandleBase::m_EDS
SmartIF< IDataProviderSvc > m_EDS
Definition: DataObjectHandleBase.h:74
DataObjectHandleBase::m_init
bool m_init
Definition: DataObjectHandleBase.h:77
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:87
DataObjectHandleBase::m_optional
bool m_optional
Definition: DataObjectHandleBase.h:78
std::lock_guard
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:93
DataObjectHandleBase::m_MS
SmartIF< IMessageSvc > m_MS
Definition: DataObjectHandleBase.h:75
DataObjectHandleBase::m_wasWritten
bool m_wasWritten
Definition: DataObjectHandleBase.h:80

## ◆ pythonRepr()

std::string DataObjectHandleBase::pythonRepr | ( |  | ) | const
| override virtual

Reimplemented from Gaudi::DataHandle.

Definition at line 112 of file DataObjectHandleBase.cpp.

112 {
113 std::string m;
114 switch ( mode() ) {
115 case Gaudi::DataHandle::Mode::Reader:
116 m = "R";
117 break;
118 case Gaudi::DataHandle::Mode::Writer:
119 m = "W";
120 break;
121 default:
122 m = "UNKNOWN";
123 break;
124 }
125 return "DataObjectHandleBase('" + toString() + "', '" + m + "')";
126 }
Gaudi::DataHandle::mode
virtual Mode mode() const
Definition: DataHandle.h:42
std::string
STL class.
Gaudi::Units::m
constexpr double m
Definition: SystemOfUnits.h:92
DataObjectHandleBase::toString
std::string toString() const
Definition: DataObjectHandleBase.cpp:109
compareOutputFiles.Reader
def Reader(readerType, filename, qacross, qToEngine)
Definition: compareOutputFiles.py:126

## ◆ setOptional()

void DataObjectHandleBase::setOptional | ( | bool | optional = `true` | ) |
| inline

Definition at line 57 of file DataObjectHandleBase.h.

57 { m_optional = optional; }
DataObjectHandleBase::m_optional
bool m_optional
Definition: DataObjectHandleBase.h:78

## ◆ setRead()

void DataObjectHandleBase::setRead | ( | bool | wasRead = `true` | ) |
| inline protected

Definition at line 66 of file DataObjectHandleBase.h.

66 { m_wasRead = wasRead; }
DataObjectHandleBase::m_wasRead
bool m_wasRead
Definition: DataObjectHandleBase.h:79
DataObjectHandleBase::wasRead
bool wasRead() const
Definition: DataObjectHandleBase.h:60

## ◆ setWritten()

void DataObjectHandleBase::setWritten | ( | bool | wasWritten = `true` | ) |
| inline protected

Definition at line 67 of file DataObjectHandleBase.h.

67 { m_wasWritten = wasWritten; }
DataObjectHandleBase::wasWritten
bool wasWritten() const
Definition: DataObjectHandleBase.h:61
DataObjectHandleBase::m_wasWritten
bool m_wasWritten
Definition: DataObjectHandleBase.h:80

## ◆ toString()

std::string DataObjectHandleBase::toString | ( |  | ) | const

Definition at line 109 of file DataObjectHandleBase.cpp.

109 { return objKey(); }
Gaudi::DataHandle::objKey
virtual const std::string & objKey() const
Definition: DataHandle.h:47

## ◆ wasRead()

bool DataObjectHandleBase::wasRead | ( |  | ) | const
| inline

Definition at line 60 of file DataObjectHandleBase.h.

60 { return m_wasRead; }
DataObjectHandleBase::m_wasRead
bool m_wasRead
Definition: DataObjectHandleBase.h:79

## ◆ wasWritten()

bool DataObjectHandleBase::wasWritten | ( |  | ) | const
| inline

Definition at line 61 of file DataObjectHandleBase.h.

61 { return m_wasWritten; }
DataObjectHandleBase::m_wasWritten
bool m_wasWritten
Definition: DataObjectHandleBase.h:80

## Friends And Related Function Documentation

## ◆ operator<<

std::ostream& operator<< | ( | std::ostream & | str,
|  | const DataObjectHandleBase & | d
| ) |  |
| friend

Definition at line 166 of file DataObjectHandleBase.cpp.

166 {
167
168 str << d.fullKey() << " m: " << d.mode();
169 if ( d.owner() ) str << " o: " << d.owner()->name();
170 str << " opt: " << d.isOptional();
171 return str;
172 }
Gaudi::DataHandle::mode
virtual Mode mode() const
Definition: DataHandle.h:42
Gaudi::DataHandle::owner
virtual IDataHandleHolder * owner() const
Definition: DataHandle.h:40
INamedInterface::name
virtual const std::string & name() const =0
Retrieve the name of the instance.
Gaudi::DataHandle::fullKey
virtual const DataObjID & fullKey() const
Definition: DataHandle.h:48
DataObjectHandleBase::isOptional
bool isOptional() const
Check if the data object declared is optional for the algorithm.
Definition: DataObjectHandleBase.h:56

## Member Data Documentation

## ◆ m_EDS

SmartIF<IDataProviderSvc> DataObjectHandleBase::m_EDS
| protected

Definition at line 74 of file DataObjectHandleBase.h.

## ◆ m_init

bool DataObjectHandleBase::m_init = false
| protected

Definition at line 77 of file DataObjectHandleBase.h.

## ◆ m_MS

SmartIF<IMessageSvc> DataObjectHandleBase::m_MS
| protected

Definition at line 75 of file DataObjectHandleBase.h.

## ◆ m_optional

bool DataObjectHandleBase::m_optional = false
| protected

Definition at line 78 of file DataObjectHandleBase.h.

## ◆ m_searchDone

bool DataObjectHandleBase::m_searchDone = false
| mutable protected

Whether the search part of the fetch method (so dealing with alt names was already executed or not.

On subsequent calls (when this is true), it will be skipped.

Definition at line 87 of file DataObjectHandleBase.h.

## ◆ m_searchMutex

std::mutex DataObjectHandleBase::m_searchMutex
| mutable protected

A Mutex protecting the calls to the search part of the fetch method, so that we are sure that we only call it once.

Definition at line 93 of file DataObjectHandleBase.h.

## ◆ m_wasRead

bool DataObjectHandleBase::m_wasRead = false
| protected

Definition at line 79 of file DataObjectHandleBase.h.

## ◆ m_wasWritten

bool DataObjectHandleBase::m_wasWritten = false
| protected

Definition at line 80 of file DataObjectHandleBase.h.

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

- GaudiKernel/GaudiKernel/DataObjectHandleBase.h
- GaudiKernel/src/Lib/DataObjectHandleBase.cpp