ATLAS Offline Software
DataHeaderCnv_p5.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
3 */
4 
11 #include "PersistentDataModel/DataHeader.h"
12 #include "PersistentDataModelTPCnv/DataHeaderCnv_p5.h"
13 #include "CxxUtils/sgkey_t.h"
14 #include "CxxUtils/starts_with.h"
15 
16 DataHeaderElementCnv_p5::DataHeaderElementCnv_p5() {}
17 DataHeaderElementCnv_p5::~DataHeaderElementCnv_p5() {}
18 
19 //______________________________________________________________________________
20 void DataHeaderElementCnv_p5::persToTrans(const DataHeaderElement_p5& pers,
21  DataHeaderElement& trans,
22  const DataHeaderForm_p5& form,
23  unsigned int entry) const
24 {
25  delete trans.m_token; trans.m_token = new Token; trans.m_ownToken = true;
26  Token* token = const_cast<Token*>(trans.m_token);
27  std::vector<unsigned int>::const_iterator intIter = form.params(entry).begin();
28  unsigned int keyIdx = 0U, aliasNum = 0U, clidNum = 0U;
29 // Translate PoolToken
30  if ((*intIter&0x0000FFFF) == 0) {
31  ++intIter;
32  keyIdx = *intIter; ++intIter;
33  aliasNum = *intIter; ++intIter;
34  clidNum = *intIter; ++intIter;
35  token->fromString(pers.m_token);
36  } else {
37  const unsigned int keyPos = (unsigned short)(*intIter>>16),
38  version = (unsigned short)(*intIter&0x0000FFFF); ++intIter;
39  const unsigned int guidIdx = (unsigned short)(*intIter>>16),
40  classIdx = (unsigned short)(*intIter&0x0000FFFF); ++intIter;
41  const unsigned int prefixIdx = (unsigned short)(*intIter>>16),
42  typeIdx = (unsigned short)(*intIter&0x0000FFFF); ++intIter;
43 // Add Technology and Offsets
44  unsigned int tech = 514;
45  if (version&0x00000001U) {
46  tech = *intIter; ++intIter;
47  }
48  unsigned int oid1 = *intIter; ++intIter;
49  if (version&0x00000010U) {
50  keyIdx = *intIter; ++intIter;
51  aliasNum = *intIter; ++intIter;
52  clidNum = *intIter; ++intIter;
53  } else {
54  keyIdx = (*intIter>>16), aliasNum = ((*intIter&0x0000FFFF)>>8), clidNum = (*intIter&0x000000FF); ++intIter;
55  }
56 // Append DbGuid
57  Guid guid(form.map()[guidIdx]);
58  token->setDb(guid);
59 // Container name, may be optimized
60  std::string cntName;
61  if (prefixIdx > 0) {
62  cntName += form.map()[prefixIdx];
63  if (typeIdx > 0) {
64  cntName += form.map()[typeIdx];
65  }
66  }
67 // Insert key
68  if (keyPos > 0) {
69  cntName += pers.m_token.substr(0, keyPos - 1) + form.map()[keyIdx] + pers.m_token.substr(keyPos - 1);
70  } else {
71  cntName += pers.m_token;
72  }
73  //token->setCont(cntName);
74 // Append ClassId
75  Guid clid(form.map()[classIdx]);
76  token->setClassID(clid);
77  token->setTechnology(tech);
78  token->setOid(Token::OID_t(oid1, pers.m_oid2));
79  }
80  unsigned int aliasCur = 0U, clidCur = 0U;
81  trans.m_key = form.map()[keyIdx];
82  trans.m_alias.clear();
83  for (std::set<std::string>::const_iterator lastAlias = trans.m_alias.begin();
84  aliasCur < aliasNum; ++aliasCur) {
85  lastAlias = trans.m_alias.insert(lastAlias, form.map()[keyIdx + aliasCur + 1]);
86  }
87  trans.m_pClid = *intIter; ++intIter;
88  trans.m_clids.clear();
89  const std::vector<unsigned int>::const_iterator intLast = form.params(entry).end();
90  for (std::set<CLID>::const_iterator lastClid = trans.m_clids.begin();
91  intIter != intLast && clidCur < clidNum; ++intIter, ++clidCur) {
92  lastClid = trans.m_clids.insert(lastClid, *intIter);
93  }
94  trans.m_hashes.clear();
95  for (; intIter != intLast; ++intIter) {
96  trans.m_hashes.push_back(*intIter);
97  }
98 }
99 //______________________________________________________________________________
100 void DataHeaderElementCnv_p5::transToPers(const DataHeaderElement& trans,
101  DataHeaderElement_p5& pers,
102  DataHeaderForm_p5& form,
103  unsigned int entry) const {
104  unsigned int tech = 0U, oid1 = 0U;
105  unsigned short guidIdx = 0U, classIdx = 0U, prefixIdx = 0U, typeIdx = 0U, keyPos = 0U;
106 // Translate PoolToken
107  if (trans.getToken() != 0) {
108 // Database GUID
109  const std::string guid = trans.getToken()->dbID().toString();
110  for (std::vector<std::string>::const_iterator iter = form.map().begin(), last = form.map().end();
111  iter != last; ++iter, ++guidIdx) {
112  if (*iter == guid) break;
113  }
114  if (guidIdx == form.map().size()) {
115  form.insertMap(guid);
116  }
117 // Class GUID
118  const std::string clid = trans.getToken()->classID().toString();
119  for (std::vector<std::string>::const_iterator iter = form.map().begin(), last = form.map().end();
120  iter != last; ++iter, ++classIdx) {
121  if (*iter == clid) break;
122  }
123  if (classIdx == form.map().size()) {
124  form.insertMap(clid);
125  }
126 // Container name, can be optimized
127  pers.m_token = trans.getToken()->contID();
128 // Get Prefix
129  std::string::size_type delim = pers.m_token.find_first_of("_/(");
130  if (delim != std::string::npos) {
131  const std::string persComp1 = pers.m_token.substr(0, delim + 1);
132  for (std::vector<std::string>::const_iterator iter = form.map().begin(), last = form.map().end();
133  iter != last; ++iter, ++prefixIdx) {
134  if (*iter == persComp1) break;
135  }
136  if (prefixIdx == form.map().size()) {
137  form.insertMap(persComp1);
138  }
139  pers.m_token = pers.m_token.substr(delim + 1);
140 // Get TypeName
141 // Check whether Key only is used for placement
142  if (!CxxUtils::starts_with (pers.m_token, trans.m_key)) {
143  std::string::size_type delim = pers.m_token.find_first_of("/()");
144  if (delim != std::string::npos) {
145  const std::string persComp2 = pers.m_token.substr(0, delim + 1);
146  for (std::vector<std::string>::const_iterator iter = form.map().begin(), last = form.map().end();
147  iter != last; ++iter, ++typeIdx) {
148  if (*iter == persComp2) break;
149  }
150  if (typeIdx == form.map().size()) {
151  form.insertMap(persComp2);
152  }
153  pers.m_token = pers.m_token.substr(delim + 1);
154  } else if (pers.m_token == "DataHeader") {
155  for (std::vector<std::string>::const_iterator iter = form.map().begin(), last = form.map().end();
156  iter != last; ++iter, ++typeIdx) {
157  if (*iter == "DataHeader") break;
158  }
159  if (typeIdx == form.map().size()) {
160  form.insertMap("DataHeader");
161  }
162  pers.m_token.clear();
163  }
164  }
165  }
166  delim = pers.m_token.rfind(trans.m_key);
167  if (delim != std::string::npos) {
168  keyPos = delim + 1;
169  pers.m_token = pers.m_token.substr(0, delim) + pers.m_token.substr(delim + trans.m_key.size());
170  }
171  tech = trans.getToken()->technology();
172  oid1 = trans.getToken()->oid().first;
173  pers.m_oid2 = trans.getToken()->oid().second;
174  }
175  unsigned int version = 0x0000FFFFU;
176  if (tech == 514) {
177  version = version&0x0000FFFEU;
178  }
179  unsigned int keyIdx = form.map().size(), aliasNum = trans.m_alias.size(), clidNum = trans.m_clids.size();
180  if (keyIdx < 0x00010000U && aliasNum < 0x00000100U && clidNum < 0x00000100U) {
181  version = version&0x0000FFEFU;
182  }
183  form.insertParam((unsigned int)(keyPos) * 0x00010000U + version, entry);
184  form.insertParam((unsigned int)(guidIdx) * 0x00010000U + (unsigned int)(classIdx), entry);
185  form.insertParam((unsigned int)(prefixIdx) * 0x00010000U + (unsigned int)(typeIdx), entry);
186  if (version&0x00000001U) {
187  form.insertParam(tech, entry);
188  }
189  form.insertParam(oid1, entry);
190  if (version&0x00000010U) {
191  form.insertParam(keyIdx, entry);
192  form.insertParam(aliasNum, entry);
193  form.insertParam(clidNum, entry);
194  } else {
195  form.insertParam(keyIdx * 0x00010000U + aliasNum * 0x00000100U + clidNum, entry);
196  }
197  form.insertMap(trans.m_key);
198  for (std::set<std::string>::const_iterator iter = trans.m_alias.begin(),
199  last = trans.m_alias.end(); iter != last; ++iter) {
200  form.insertMap(*iter);
201  }
202  form.insertParam(trans.m_pClid, entry);
203  for (std::set<CLID>::const_iterator iter = trans.m_clids.begin(),
204  last = trans.m_clids.end(); iter != last; ++iter) {
205  form.insertParam(*iter, entry);
206  }
207  for (std::vector<SG::sgkey_t>::const_iterator iter = trans.m_hashes.begin(),
208  last = trans.m_hashes.end(); iter != last; ++iter) {
209  form.insertParam(SG::sgkeyShort (*iter), entry);
210  }
211 }
212 //______________________________________________________________________________
213 //______________________________________________________________________________
214 DataHeaderCnv_p5::DataHeaderCnv_p5() {}
215 DataHeaderCnv_p5::~DataHeaderCnv_p5() {}
216 //______________________________________________________________________________
217 void DataHeaderCnv_p5::persToTrans(const DataHeader_p5& pers,
218  DataHeader& trans,
219  const DataHeaderForm_p5& dhForm) const
220 {
221  unsigned int entry = 1;
222  const unsigned int provSize = dhForm.params(entry)[0];
223  trans.m_inputDataHeader.resize(provSize);
224  std::vector<DataHeaderElement>::iterator it = trans.m_inputDataHeader.begin();
225  std::vector<DataHeaderElement_p5>::const_iterator pit = pers.m_dataHeader.begin();
226  for (unsigned int i = 0U; i < provSize; ++i, ++it, ++pit) {
227  ++entry;
228  m_elemCnv.persToTrans(*pit, *it, dhForm, entry);
229  }
230  trans.m_dataHeader.resize(pers.m_dataHeader.size() - provSize);
231  it = trans.m_dataHeader.begin();
232  for (std::vector<DataHeaderElement_p5>::const_iterator last = pers.m_dataHeader.end();
233  pit != last; ++it, ++pit) {
234  ++entry;
235  m_elemCnv.persToTrans(*pit, *it, dhForm, entry);
236  }
237  trans.setStatus(DataHeader::Input);
238 }
239 //______________________________________________________________________________
240 void DataHeaderCnv_p5::transToPers(const DataHeader& trans,
241  DataHeader_p5& pers,
242  DataHeaderForm_p5& dhForm) const
243 {
244  const unsigned int provSize = trans.m_inputDataHeader.size();
245  pers.m_dataHeader.resize(provSize + trans.m_dataHeader.size());
246  dhForm.resize(provSize + trans.m_dataHeader.size() + 2);
247  unsigned int entry = 1;
248  dhForm.insertParam(provSize, entry);
249  std::vector<DataHeaderElement_p5>::iterator pit = pers.m_dataHeader.begin();
250  for (std::vector<DataHeaderElement>::const_iterator it = trans.m_inputDataHeader.begin(),
251  last = trans.m_inputDataHeader.end(); it != last; ++it, ++pit) {
252  ++entry;
253  m_elemCnv.transToPers(*it, *pit, dhForm, entry);
254  }
255  for (std::vector<DataHeaderElement>::const_iterator it = trans.m_dataHeader.begin(),
256  last = trans.m_dataHeader.end(); it != last; ++it, ++pit) {
257  ++entry;
258  m_elemCnv.transToPers(*it, *pit, dhForm, entry);
259  }
260 }
261 //______________________________________________________________________________
262 void DataHeaderCnv_p5::insertDHRef(DataHeader_p5& pers,
263  DataHeaderForm_p5& dhForm,
264  const std::string& key,
265  const std::string& strToken) const
266 {
267  Token* token = new Token;
268  token->fromString(strToken);
269  DataHeaderElement tEle(ClassID_traits<DataHeader>::ID(), key, token);
270  DataHeaderElement_p5 pEle;
271  unsigned int entry = dhForm.size() + 1;
272  m_elemCnv.transToPers(tEle, pEle, dhForm, entry);
273  pers.m_dataHeader.push_back(pEle);
274 }
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
DataHeaderElementCnv_p5::transToPers
void transToPers(const DataHeaderElement &trans, DataHeaderElement_p5 &pers, DataHeaderForm_p5 &form, unsigned int entry) const
Definition: DataHeaderCnv_p5.cxx:100
DataHeaderElement_p5::m_token
std::string m_token
Definition: DataHeader_p5.h:35
DataHeaderElement::m_key
std::string m_key
string with StoreGate key.
Definition: DataHeader.h:111
xAOD::short
short
Definition: Vertex_v1.cxx:165
CxxUtils::starts_with
bool starts_with(const char *s, const char *prefix)
Test whether one null-terminated byte string starts with another.
Token::contID
const std::string & contID() const
Access container identifier.
Definition: Token.h:67
DataHeaderCnv_p5::insertDHRef
void insertDHRef(DataHeader_p5 &pers, DataHeaderForm_p5 &dhForm, const std::string &key, const std::string &strToken) const
Definition: DataHeaderCnv_p5.cxx:262
DataHeader::Input
@ Input
Definition: DataHeader.h:126
DataHeaderElement::m_clids
std::set< CLID > m_clids
set of unsigned long to store ClassID's for symlinked container.
Definition: DataHeader.h:109
DataHeaderElement::m_pClid
CLID m_pClid
primary ClassID.
Definition: DataHeader.h:107
skel.it
it
Definition: skel.GENtoEVGEN.py:423
Token::dbID
const Guid & dbID() const
Access database identifier.
Definition: Token.h:62
DataHeaderForm_p5
This class provides storage for the constant fields of the persistent DataHeader class.
Definition: DataHeader_p5.h:42
Guid::toString
const std::string toString() const
Automatic conversion to string representation.
Definition: Guid.cxx:58
DataHeaderCnv_p5::DataHeaderCnv_p5
DataHeaderCnv_p5()
Definition: DataHeaderCnv_p5.cxx:214
DataHeaderForm_p5::map
const std::vector< std::string > & map() const
Definition: DataHeader_p5.cxx:45
DataHeaderForm_p5::resize
void resize(unsigned int size)
Definition: DataHeader_p5.cxx:65
Token::classID
const Guid & classID() const
Access database identifier.
Definition: Token.h:71
DataHeaderElement::m_ownToken
bool m_ownToken
Definition: DataHeader.h:116
DataHeaderCnv_p5::~DataHeaderCnv_p5
~DataHeaderCnv_p5()
Definition: DataHeaderCnv_p5.cxx:215
DataHeaderElementCnv_p5::DataHeaderElementCnv_p5
DataHeaderElementCnv_p5()
Definition: DataHeaderCnv_p5.cxx:16
Token
This class provides a token that identifies in a unique way objects on the persistent storage.
Definition: Token.h:21
DataHeaderElementCnv_p5::~DataHeaderElementCnv_p5
~DataHeaderElementCnv_p5()
Definition: DataHeaderCnv_p5.cxx:17
DataHeaderForm_p5::params
const std::vector< unsigned int > & params(unsigned int entry) const
Definition: DataHeader_p5.cxx:53
Token::OID_t
Definition: Token.h:24
Token::fromString
Token & fromString(const std::string &from)
Build from the string representation of a token.
Definition: Token.cxx:133
Token::setClassID
Token & setClassID(const Guid &cl_id)
Access database identifier.
Definition: Token.h:73
DataHeaderElement
This class provides a persistent form for the TransientAddress.
Definition: DataHeader.h:36
Token::technology
int technology() const
Access technology type.
Definition: Token.h:75
DataHeaderElement::m_alias
std::set< std::string > m_alias
set of StoreGate alias string.
Definition: DataHeader.h:113
DataHeader
This class provides the layout for summary information stored for data written to POOL.
Definition: DataHeader.h:124
lumiFormat.i
int i
Definition: lumiFormat.py:92
DataHeader_p5::m_dataHeader
std::vector< DataHeaderElement_p5 > m_dataHeader
Definition: DataHeader_p5.h:84
SG::sgkeyShort
constexpr uint32_t sgkeyShort(const sgkey_t k)
Convert a sgkey to the 32-bit form used for older data.
Definition: CxxUtils/CxxUtils/sgkey_t.h:85
DataHeaderForm_p5::size
unsigned int size() const
Definition: DataHeader_p5.cxx:61
ClassID_traits
Default, invalid implementation of ClassID_traits.
Definition: Control/AthenaKernel/AthenaKernel/ClassID_traits.h:40
Token::setDb
Token & setDb(const Guid &db)
Set database name.
Definition: Token.h:64
DataHeaderCnv_p5.h
This file contains the class definition for the DataHeaderCnv_p5 and DataHeaderElementCnv_p5 classes.
DataHeaderElement_p5::m_oid2
long long int m_oid2
Definition: DataHeader_p5.h:36
Token::setTechnology
Token & setTechnology(int t)
Set technology type.
Definition: Token.h:77
DataHeader.h
This file contains the class definition for the DataHeader and DataHeaderElement classes.
starts_with.h
C++20-like starts_with/ends_with for strings.
DataHeaderForm_p5::insertMap
void insertMap(const std::string &element)
Definition: DataHeader_p5.cxx:49
pool_uuid.guid
guid
Definition: pool_uuid.py:112
GetAllXsec.entry
list entry
Definition: GetAllXsec.py:132
DataHeader::setStatus
void setStatus(statusFlag status)
Set StatusFlag enum for DataHeader.
Definition: DataHeader.cxx:235
DataHeader::m_dataHeader
std::vector< DataHeaderElement > m_dataHeader
vector with DataHeaderElement to "DataObject".
Definition: DataHeader.h:201
Token::setOid
Token & setOid(const OID_t &oid)
Set object identifier.
Definition: Token.h:83
DataHeaderElement_p5
This class provides a persistent representation for the DataHeaderElement class.
Definition: DataHeader_p5.h:21
DataHeaderElement::m_hashes
std::vector< sgkey_t > m_hashes
hash table for ElementLink host container keys.
Definition: DataHeader.h:118
get_generator_info.version
version
Definition: get_generator_info.py:33
Guid
This class provides a encapsulation of a GUID/UUID/CLSID/IID data structure (128 bit number).
Definition: Guid.h:20
sgkey_t.h
Define the type used for hashed StoreGate key+CLID pairs.
DataHeaderCnv_p5::persToTrans
void persToTrans(const DataHeader_p5 &pers, DataHeader &trans, const DataHeaderForm_p5 &dhForm) const
Definition: DataHeaderCnv_p5.cxx:217
DataHeaderForm_p5::insertParam
void insertParam(unsigned int param, unsigned int entry)
Definition: DataHeader_p5.cxx:57
DataHeader_p5
This class provides a persistent representation for the DataHeader class.
Definition: DataHeader_p5.h:67
Token::oid
const OID_t & oid() const
Access object identifier.
Definition: Token.h:79
DataHeaderElement::m_token
const Token * m_token
pointer to transient address
Definition: DataHeader.h:115
DataHeaderCnv_p5::m_elemCnv
DataHeaderElementCnv_p5 m_elemCnv
Definition: DataHeaderCnv_p5.h:65
DataHeaderElement::getToken
const Token * getToken() const
Definition: DataHeader.cxx:135
DataHeaderElementCnv_p5::persToTrans
void persToTrans(const DataHeaderElement_p5 &pers, DataHeaderElement &trans, const DataHeaderForm_p5 &form, unsigned int entry) const
Definition: DataHeaderCnv_p5.cxx:20
DataHeaderCnv_p5::transToPers
void transToPers(const DataHeader &trans, DataHeader_p5 &pers, DataHeaderForm_p5 &dhForm) const
Definition: DataHeaderCnv_p5.cxx:240
DataHeader::m_inputDataHeader
std::vector< DataHeaderElement > m_inputDataHeader
vector with DataHeaderElement to upstream DataHeader ("Provenance").
Definition: DataHeader.h:203
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
Generated on Tue Jul 2 2024 21:13:28 for ATLAS Offline Software by   doxygen 1.8.18