All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
MinimalDataObjectHandle.cpp
Go to the documentation of this file.
1 #include "GaudiKernel/MinimalDataObjectHandle.h"
2 #include "GaudiKernel/DataObjectDescriptor.h"
3 #include "GaudiKernel/ContextSpecificPtr.h"
4 
5 //---------------------------------------------------------------------------
6 
8  m_descriptor(new DataObjectDescriptor(DataObjectDescriptor::NULL_,
9  DataObjectDescriptor::NULL_)),
10 
11  m_dataProductIndex(-1),
12  m_wasRead(false),
13  m_wasWritten(false),
14  m_initialized(false){
15 }
16 
18  m_descriptor(&descriptor),
19  m_dataProductIndex(updateDataProductIndex()),
20  m_wasRead(false),
21  m_wasWritten(false),
22  m_initialized(false){
23 }
24 
26  delete m_descriptor;
27 }
28 
29 //---------------------------------------------------------------------------
30 
32  setRead(false);
33  setWritten(false);
34 
35  m_initialized = true;
36  return StatusCode::SUCCESS;
37 }
38 
39 //---------------------------------------------------------------------------
40 
42  setRead(false);
43  setWritten(false);
44  return StatusCode::SUCCESS;
45 }
46 
47 //---------------------------------------------------------------------------
48 
50  return StatusCode::SUCCESS;
51 }
52 
53 //---------------------------------------------------------------------------
54 
56  return m_descriptor->optional();
57 }
58 
60  m_descriptor->setOptional(optional);
61 }
62 
63 //---------------------------------------------------------------------------
64 
66  return m_dataProductIndex;
67 }
68 
69 //---------------------------------------------------------------------------
70 
71 const std::string& MinimalDataObjectHandle::dataProductName() const {
72  return m_descriptor->address();
73 }
74 
75 const std::vector<std::string> & MinimalDataObjectHandle::alternativeDataProductNames() const{
77 }
78 
80  //only allowed if not initialized yet
81  if(m_initialized)
82  return StatusCode::FAILURE;
83 
84  m_descriptor->setAddress(address);
85 
87 
88  return StatusCode::SUCCESS;
89 }
90 
91 StatusCode MinimalDataObjectHandle::setAlternativeDataProductNames(const std::vector<std::string> & alternativeAddresses){
92  //only allowed if not initialized yet
93  if(m_initialized)
94  return StatusCode::FAILURE;
95 
96  m_descriptor->setAltAddresses(alternativeAddresses);
97 
99 
100  return StatusCode::SUCCESS;
101 }
102 
103 StatusCode MinimalDataObjectHandle::setDataProductNames(const std::vector<std::string> & addresses){
104  //only allowed if not initialized yet
105  if(m_initialized)
106  return StatusCode::FAILURE;
107 
108  m_descriptor->setAddresses(addresses);
109 
111 
112  return StatusCode::SUCCESS;
113 }
114 
115 //---------------------------------------------------------------------------
116 
118  return m_descriptor->accessType();
119 }
120 
121 //---------------------------------------------------------------------------
122 
124  return m_wasRead;
125 }
126 
127 //---------------------------------------------------------------------------
128 
130  return m_descriptor->valid();
131 }
132 
133 //---------------------------------------------------------------------------
134 
136  return m_wasWritten;
137 }
138 
139 //---------------------------------------------------------------------------
140 
142 
143 //---------------------------------------------------------------------------
144 
146 
147 //---------------------------------------------------------------------------
148 
150 
151 //---------------------------------------------------------------------------
152 
153 //---------------------------------------------------------------------------
154 std::unordered_map<std::string, size_t> MinimalDataObjectHandle::m_dataProductIndexMap;
155 
158  m_dataProductIndex = -1;
159  else {
160  auto idx = m_dataProductIndexMap.find(dataProductName());
161  if(idx != m_dataProductIndexMap.end())
162  m_dataProductIndex = idx->second;
163  else{
164  auto res = m_dataProductIndexMap.emplace(dataProductName(), m_dataProductIndexMap.size());
165  m_dataProductIndex = res.first->second;
166  }
167  }
168 
169  return m_dataProductIndex;
170 }
171 
172 //---------------------------------------------------------------------------
173 
174 //methods dealing with locking mechanism
175 
176 std::map<size_t, std::map<size_t, tbb::spin_mutex> > MinimalDataObjectHandle::m_locks;
177 
180 }
181 
184 
186  for(auto & lock : m_locks[Gaudi::Hive::currentContextId()]){
187  //non-blocking call to try_lock
188  //if we can get the lock, then it wasn't set before -- delete it
189  if(lock.second.try_lock()){
191  }
192  }
193 
194  }
195 }
const std::vector< std::string > & alternativeDataProductNames() const
DataObjectDescriptor * descriptor()
MinimalDataObjectHandle::AccessType accessType() const
static std::map< size_t, std::map< size_t, tbb::spin_mutex > > m_locks
virtual StatusCode finalize()
Finalize.
void setAltAddresses(const std::vector< std::string > &addresses)
const std::string & dataProductName() const
Return the product name.
virtual StatusCode initialize()
Initialize.
void setRead(bool wasRead=true)
bool isOptional() const
Check if the data object declared is optional for the algorithm.
void setOptional(bool optional=true)
StatusCode setDataProductName(const std::string &address)
Update address of data product if possible -> not if was written.
StatusCode setAlternativeDataProductNames(const std::vector< std::string > &alternativeAddresses)
void setAddress(const std::string &address)
GAUDI_API ContextIdType currentContextId()
Return the current context id.
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:26
virtual StatusCode reinitialize()
Reinitialize -> may be overwritten in derived class.
const std::string & address() const
void setWritten(bool wasWritten=true)
void setAddresses(const std::vector< std::string > &address)
DataObjectDescriptor * m_descriptor
void setOptional(bool optional)
size_t dataProductIndex() const
Return the product index.
AccessType accessType() const
Access type.
bool wasWritten() const
Check if operation was performed.
StatusCode setDataProductNames(const std::vector< std::string > &addresses)
static const std::string NULL_
AccessType
The type of the access.
bool wasRead() const
Check if operation was performed.
static std::unordered_map< std::string, size_t > m_dataProductIndexMap
const std::vector< std::string > & alternativeAddresses() const