CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
IOVProxy.cc
Go to the documentation of this file.
1 #include <memory>
2 
4 #include "SessionImpl.h"
5 
6 namespace cond {
7 
8  namespace persistency {
9 
10  // comparison functor for iov tuples: Time_t only and Time_t,string
11  struct IOVComp {
12  bool operator()(const cond::Time_t& x, const cond::Time_t& y) { return (x < y); }
13 
14  bool operator()(const cond::Time_t& x, const std::tuple<cond::Time_t, cond::Hash>& y) {
15  return (x < std::get<0>(y));
16  }
17  };
18 
19  // function to search in the vector the target time
20  template <typename T>
21  typename std::vector<T>::const_iterator search(const cond::Time_t& val, const std::vector<T>& container) {
22  if (container.empty())
23  return container.end();
24  auto p = std::upper_bound(container.begin(), container.end(), val, IOVComp());
25  return (p != container.begin()) ? p - 1 : container.end();
26  }
27 
28  IOVArray::Iterator::Iterator() : m_current(), m_parent(nullptr) {}
29 
30  IOVArray::Iterator::Iterator(IOVContainer::const_iterator current, const IOVArray* parent)
31  : m_current(current), m_parent(parent) {}
32 
33  IOVArray::Iterator::Iterator(const Iterator& rhs) : m_current(rhs.m_current), m_parent(rhs.m_parent) {}
34 
36  if (this != &rhs) {
37  m_current = rhs.m_current;
38  m_parent = rhs.m_parent;
39  }
40  return *this;
41  }
42 
44  cond::Iov_t retVal;
45  retVal.since = std::get<0>(*m_current);
46  auto next = m_current;
47  next++;
48 
49  // default is the end of validity when set...
50  retVal.till = m_parent->m_tagInfo.endOfValidity;
51  retVal.till = cond::time::tillTimeFromNextSince(std::get<0>(*next), m_parent->m_tagInfo.timeType);
52  retVal.payloadId = std::get<1>(*m_current);
53  return retVal;
54  }
55 
57  m_current++;
58  return *this;
59  }
60 
62  Iterator tmp(*this);
63  operator++();
64  return tmp;
65  }
66 
67  bool IOVArray::Iterator::operator==(const Iterator& rhs) const {
68  if (m_current != rhs.m_current)
69  return false;
70  if (m_parent != rhs.m_parent)
71  return false;
72  return true;
73  }
74 
75  bool IOVArray::Iterator::operator!=(const Iterator& rhs) const { return !operator==(rhs); }
76 
78 
79  IOVArray::IOVArray(const IOVArray& rhs) : m_array(), m_tagInfo(rhs.m_tagInfo) {
80  m_array = std::make_unique<IOVContainer>(*rhs.m_array);
81  }
82 
84  m_array = std::make_unique<IOVContainer>(*rhs.m_array);
85  m_tagInfo = rhs.m_tagInfo;
86  return *this;
87  }
88 
89  const cond::Tag_t& IOVArray::tagInfo() const { return m_tagInfo; }
90 
91  IOVArray::Iterator IOVArray::begin() const { return Iterator(m_array->begin(), this); }
92 
93  IOVArray::Iterator IOVArray::end() const { return Iterator(m_array->end(), this); }
94 
96 
97  size_t IOVArray::size() const { return m_array->size(); }
98 
99  // returns true if at least one IOV is in the sequence.
100  bool IOVArray::isEmpty() const { return m_array->empty(); }
101 
102  // implementation details...
103  // only hosting data in this case
104  class IOVProxyData {
105  public:
107 
108  // tag data
110  // iov data
111  boost::posix_time::ptime snapshotTime;
114  bool cacheInitialized = false;
115  std::vector<cond::Time_t> sinceGroups;
117  // monitoring data
118  size_t numberOfQueries = 0;
119  };
120 
121  IOVProxy::IOVProxy() : m_data(), m_session() {}
122 
123  IOVProxy::IOVProxy(const std::shared_ptr<SessionImpl>& session) : m_data(new IOVProxyData), m_session(session) {}
124 
125  IOVProxy::IOVProxy(const IOVProxy& rhs) : m_data(rhs.m_data), m_session(rhs.m_session) {}
126 
128  m_data = rhs.m_data;
129  m_session = rhs.m_session;
130  return *this;
131  }
132 
134  boost::posix_time::ptime notime;
135  load(tagName, notime);
136  }
137 
138  void IOVProxy::load(const std::string& tagName, const boost::posix_time::ptime& snapshotTime) {
139  if (!m_data.get())
140  return;
141 
142  // clear
143  reset();
144 
145  checkTransaction("IOVProxyNew::load");
146 
147  int dummy;
148  if (!m_session->iovSchema().tagTable().select(tagName,
149  m_data->tagInfo.timeType,
150  m_data->tagInfo.payloadType,
151  m_data->tagInfo.synchronizationType,
152  m_data->tagInfo.endOfValidity,
153  m_data->tagInfo.lastValidatedTime,
154  dummy)) {
155  throwException("Tag \"" + tagName + "\" has not been found in the database.", "IOVProxy::load");
156  }
157  m_data->tagInfo.name = tagName;
158  m_data->snapshotTime = snapshotTime;
159  }
160 
162  //if( !m_data.get() ) return;
163 
164  // clear
165  resetIOVCache();
166 
167  //checkTransaction( "IOVProxyNew::load" );
168  m_session->iovSchema().iovTable().getGroups(m_data->tagInfo.name,
169  m_data->snapshotTime,
170  cond::time::sinceGroupSize(m_data->tagInfo.timeType),
171  m_data->sinceGroups);
172  m_data->cacheInitialized = true;
173  }
174 
176  boost::posix_time::ptime no_time;
177  return selectAll(no_time);
178  }
179 
180  IOVArray IOVProxy::selectAll(const boost::posix_time::ptime& snapshottime) {
181  if (!m_data.get())
182  throwException("No tag has been loaded.", "IOVProxy::selectAll");
183  checkTransaction("IOVProxy::selectAll");
184  IOVArray ret;
185  ret.m_tagInfo = m_data->tagInfo;
186  m_session->iovSchema().iovTable().select(
187  m_data->tagInfo.name, cond::time::MIN_VAL, cond::time::MAX_VAL, snapshottime, *ret.m_array);
188  return ret;
189  }
190 
192  boost::posix_time::ptime no_time;
193  return selectRange(begin, end, no_time);
194  }
195 
197  const cond::Time_t& end,
198  const boost::posix_time::ptime& snapshotTime) {
199  if (!m_data.get())
200  throwException("No tag has been loaded.", "IOVProxy::selectRange");
201 
202  checkTransaction("IOVProxy::selectRange");
203 
204  IOVArray ret;
205  ret.m_tagInfo = m_data->tagInfo;
206  m_session->iovSchema().iovTable().getRange(m_data->tagInfo.name, begin, end, snapshotTime, *ret.m_array);
207  return ret;
208  }
209 
211  if (!m_data.get())
212  throwException("No tag has been loaded.", "IOVProxy::selectRange");
213 
214  checkTransaction("IOVProxy::selectRange");
215 
216  boost::posix_time::ptime no_time;
217  size_t prevSize = destination.size();
218  m_session->iovSchema().iovTable().getRange(m_data->tagInfo.name, begin, end, no_time, destination);
219  size_t niov = destination.size() - prevSize;
220  return niov > 0;
221  }
222 
223  //void IOVProxy::reload(){
224  // if(m_data.get() && !m_data->tagInfo.empty()) {
225  // if(m_data->range) loadRange( m_data->tag, m_data->groupLowerIov, m_data->groupHigherIov, m_data->snapshotTime );
226  // else load( m_data->tag, m_data->snapshotTime, m_data->full );
227  // }
228  //}
229 
231  if (m_data.get()) {
232  m_data->groupLowerIov = cond::time::MAX_VAL;
233  m_data->groupHigherIov = cond::time::MIN_VAL;
234  m_data->sinceGroups.clear();
235  m_data->iovSequence.clear();
236  m_data->numberOfQueries = 0;
237  }
238  }
239 
241  if (m_data.get()) {
242  m_data->tagInfo.clear();
243  }
244  resetIOVCache();
245  }
246 
247  cond::Tag_t IOVProxy::tagInfo() const { return m_data.get() ? m_data->tagInfo : cond::Tag_t(); }
248 
250  if (endOfValidity < cond::time::MAX_VAL) {
251  if (target.since >= endOfValidity) {
252  target.clear();
253  } else {
254  target.till = endOfValidity;
255  }
256  } else {
258  }
259  }
260 
262  if (!m_data.get())
263  throwException("No tag has been loaded.", "IOVProxy::iovSequenceInfo");
264  checkTransaction("IOVProxy::iovSequenceInfo");
266  m_session->iovSchema().iovTable().getSize(m_data->tagInfo.name, m_data->snapshotTime, ret.size);
268  bool ok = m_session->iovSchema().iovTable().getLastIov(
269  m_data->tagInfo.name, m_data->snapshotTime, ret.lastInterval.since, ret.lastInterval.payloadId);
270  if (ok) {
271  setTillToLastIov(ret.lastInterval, m_data->tagInfo.endOfValidity);
272  }
273  return ret;
274  }
275 
276  std::tuple<std::string, boost::posix_time::ptime, boost::posix_time::ptime> IOVProxy::getMetadata() const {
277  if (!m_data.get())
278  throwException("No tag has been loaded.", "IOVProxy::getMetadata");
279  checkTransaction("IOVProxy::getMetadata");
280  std::tuple<std::string, boost::posix_time::ptime, boost::posix_time::ptime> ret;
281  if (!m_session->iovSchema().tagTable().getMetadata(
282  m_data->tagInfo.name, std::get<0>(ret), std::get<1>(ret), std::get<2>(ret))) {
283  throwException("Metadata for tag \"" + m_data->tagInfo.name + "\" have not been found in the database.",
284  "IOVProxy::getMetadata");
285  }
286  return ret;
287  }
288 
289  void IOVProxy::checkTransaction(const std::string& ctx) const {
290  if (!m_session.get())
291  throwException("The session is not active.", ctx);
292  if (!m_session->isTransactionActive(false))
293  throwException("The transaction is not active.", ctx);
294  }
295 
296  void IOVProxy::fetchSequence(cond::Time_t lowerGroup, cond::Time_t higherGroup) {
297  m_data->iovSequence.clear();
298  m_session->iovSchema().iovTable().select(
299  m_data->tagInfo.name, lowerGroup, higherGroup, m_data->snapshotTime, m_data->iovSequence);
300 
301  if (m_data->iovSequence.empty()) {
302  m_data->groupLowerIov = cond::time::MAX_VAL;
303  m_data->groupHigherIov = cond::time::MIN_VAL;
304  } else {
305  if (lowerGroup > cond::time::MIN_VAL) {
306  m_data->groupLowerIov = std::get<0>(m_data->iovSequence.front());
307  } else {
308  m_data->groupLowerIov = cond::time::MIN_VAL;
309  }
310  m_data->groupHigherIov = std::get<0>(m_data->iovSequence.back());
311  if (higherGroup < cond::time::MAX_VAL) {
312  m_data->groupHigherIov = cond::time::tillTimeFromNextSince(higherGroup, m_data->tagInfo.timeType);
313  } else {
314  m_data->groupHigherIov = cond::time::MAX_VAL;
315  }
316  }
317 
318  m_data->numberOfQueries++;
319  }
320 
322 
324  if (!m_data.get())
325  throwException("No tag has been loaded.", "IOVProxy::getInterval");
326  checkTransaction("IOVProxy::getInterval");
327  if (!m_data->cacheInitialized)
328  loadGroups();
329  cond::Iov_t retVal;
330  // organize iovs in pages...
331  // first check the available iov cache:
332  if (m_data->groupLowerIov == cond::time::MAX_VAL || // case 0 : empty cache ( the first request )
333  time < m_data->groupLowerIov || time >= m_data->groupHigherIov) { // case 1 : target outside
334 
335  // a new query required!
336  // first determine the groups
337  auto iGLow = search(time, m_data->sinceGroups);
338  if (iGLow == m_data->sinceGroups.end()) {
339  // no suitable group=no iov at all! exiting...
340  return retVal;
341  }
342  auto iGHigh = iGLow;
343  cond::Time_t lowG = *iGLow;
344  iGHigh++;
346  if (iGHigh != m_data->sinceGroups.end())
347  highG = *iGHigh;
348 
349  // finally, get the iovs for the selected group interval!!
350  fetchSequence(lowG, highG);
351  }
352 
353  // the current iov set is a good one...
354  auto iIov = search(time, m_data->iovSequence);
355  if (iIov == m_data->iovSequence.end()) {
356  return retVal;
357  }
358 
359  retVal.since = std::get<0>(*iIov);
360  auto next = iIov;
361  next++;
362 
363  // default is the end of validity when set...
364  retVal.till = m_data->tagInfo.endOfValidity;
365  // for the till, the next element of the sequence has to be looked up
366  cond::Time_t tillVal;
367  if (next != m_data->iovSequence.end()) {
368  tillVal = cond::time::tillTimeFromNextSince(std::get<0>(*next), m_data->tagInfo.timeType);
369  } else {
370  tillVal = m_data->groupHigherIov;
371  }
372  if (tillVal < retVal.till)
373  retVal.till = tillVal;
374  //
375  retVal.payloadId = std::get<1>(*iIov);
376  if (retVal.till == cond::time::MAX_VAL && defaultIovSize != cond::time::MAX_VAL) {
377  if (defaultIovSize == 0) {
378  // ???? why?
379  retVal.clear();
380  } else {
381  retVal.since = time;
382  retVal.till = retVal.since + defaultIovSize - 1;
383  if (time > retVal.till)
384  retVal.till = time;
385  }
386  }
387  return retVal;
388  }
389 
391  checkTransaction("IOVProxy::getLast");
393  bool ok = m_session->iovSchema().iovTable().getLastIov(
394  m_data->tagInfo.name, m_data->snapshotTime, ret.since, ret.payloadId);
395  if (ok) {
396  setTillToLastIov(ret, m_data->tagInfo.endOfValidity);
397  }
398  return ret;
399  }
400 
401  int IOVProxy::loadedSize() const { return m_data.get() ? m_data->iovSequence.size() : 0; }
402 
404  checkTransaction("IOVProxy::sequenceSize");
405  size_t ret = 0;
406  m_session->iovSchema().iovTable().getSize(m_data->tagInfo.name, m_data->snapshotTime, ret);
407 
408  return ret;
409  }
410 
411  size_t IOVProxy::numberOfQueries() const { return m_data.get() ? m_data->numberOfQueries : 0; }
412 
413  std::pair<cond::Time_t, cond::Time_t> IOVProxy::loadedGroup() const {
414  return m_data.get() ? std::make_pair(m_data->groupLowerIov, m_data->groupHigherIov)
415  : std::make_pair(cond::time::MAX_VAL, cond::time::MIN_VAL);
416  }
417 
418  const std::shared_ptr<SessionImpl>& IOVProxy::session() const { return m_session; }
419 
420  } // namespace persistency
421 
422 } // namespace cond
runTheMatrix.ret
ret
prodAgent to be discontinued
Definition: runTheMatrix.py:373
cond::persistency::IOVProxyData::IOVProxyData
IOVProxyData()
Definition: IOVProxy.cc:106
pfDeepBoostedJetPreprocessParams_cfi.upper_bound
upper_bound
Definition: pfDeepBoostedJetPreprocessParams_cfi.py:16
cond::time::MIN_VAL
const Time_t MIN_VAL(0)
cond::persistency::IOVArray::begin
Iterator begin() const
Definition: IOVProxy.cc:91
cond::persistency::IOVProxy::getLast
cond::Iov_t getLast()
Definition: IOVProxy.cc:390
cond::persistency::IOVComp::operator()
bool operator()(const cond::Time_t &x, const std::tuple< cond::Time_t, cond::Hash > &y)
Definition: IOVProxy.cc:14
cond::persistency::IOVProxy::getMetadata
std::tuple< std::string, boost::posix_time::ptime, boost::posix_time::ptime > getMetadata() const
Definition: IOVProxy.cc:276
cond::persistency::IOVProxy::getInterval
cond::Iov_t getInterval(cond::Time_t time)
Definition: IOVProxy.cc:321
cond::persistency::IOVArray::end
Iterator end() const
Definition: IOVProxy.cc:93
cond::persistency::setTillToLastIov
void setTillToLastIov(cond::Iov_t &target, cond::Time_t endOfValidity)
Definition: IOVProxy.cc:249
AlCaHLTBitMon_ParallelJobs.p
p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
cond::persistency::IOVProxy::loadedSize
int loadedSize() const
Definition: IOVProxy.cc:401
cond::persistency::IOVProxy::selectRange
IOVArray selectRange(const cond::Time_t &begin, const cond::Time_t &end)
Definition: IOVProxy.cc:191
loadRecoTauTagMVAsFromPrepDB_cfi.snapshotTime
snapshotTime
Definition: loadRecoTauTagMVAsFromPrepDB_cfi.py:10
cond::persistency::IOVArray::m_array
std::unique_ptr< IOVContainer > m_array
Definition: IOVProxy.h:87
cond::persistency::IOVProxyData::groupLowerIov
cond::Time_t groupLowerIov
Definition: IOVProxy.cc:112
createJobs.tmp
tmp
align.sh
Definition: createJobs.py:716
convertSQLiteXML.ok
bool ok
Definition: convertSQLiteXML.py:98
cond::persistency::IOVProxy::selectAll
IOVArray selectAll()
Definition: IOVProxy.cc:175
cond::persistency::IOVArray::operator=
IOVArray & operator=(const IOVArray &rhs)
Definition: IOVProxy.cc:83
cond::persistency::IOVArray::Iterator
friend class Iterator
Definition: IOVProxy.h:63
cond::persistency::IOVProxy::load
void load(const std::string &tag)
Definition: IOVProxy.cc:133
cond::persistency::IOVArray::find
Iterator find(cond::Time_t time) const
Definition: IOVProxy.cc:95
dqmdumpme.last
last
Definition: dqmdumpme.py:56
cond::persistency::IOVComp::operator()
bool operator()(const cond::Time_t &x, const cond::Time_t &y)
Definition: IOVProxy.cc:12
cond::persistency::IOVProxy::resetIOVCache
void resetIOVCache()
Definition: IOVProxy.cc:230
cond::time::tillTimeFromNextSince
Time_t tillTimeFromNextSince(Time_t nextSince, TimeType timeType)
Definition: Time.cc:34
cond::persistency::IOVArray
Definition: IOVProxy.h:29
IOVProxy.h
cond::persistency::IOVProxy::iovSequenceInfo
cond::TagInfo_t iovSequenceInfo() const
Definition: IOVProxy.cc:261
cond::Iov_t::till
Time_t till
Definition: Types.h:54
SessionImpl.h
cond::persistency::IOVProxy::loadGroups
void loadGroups()
Definition: IOVProxy.cc:161
mps_fire.end
end
Definition: mps_fire.py:242
cond::persistency::IOVProxy::session
const std::shared_ptr< SessionImpl > & session() const
Definition: IOVProxy.cc:418
cond::persistency::IOVProxyData::sinceGroups
std::vector< cond::Time_t > sinceGroups
Definition: IOVProxy.cc:115
cond::persistency::IOVProxyData::groupHigherIov
cond::Time_t groupHigherIov
Definition: IOVProxy.cc:113
cond::persistency::search
std::vector< T >::const_iterator search(const cond::Time_t &val, const std::vector< T > &container)
Definition: IOVProxy.cc:21
cond::persistency::IOVProxyData::tagInfo
cond::Tag_t tagInfo
Definition: IOVProxy.cc:109
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
cond::persistency::IOVProxy
Definition: IOVProxy.h:92
cond::persistency::IOVProxyData::snapshotTime
boost::posix_time::ptime snapshotTime
Definition: IOVProxy.cc:111
cond
Definition: plugin.cc:23
operator==
bool operator==(const QGLikelihoodParameters &lhs, const QGLikelihoodCategory &rhs)
Test if parameters are compatible with category.
Definition: QGLikelihoodObject.h:49
cond::persistency::IOVArray::Iterator::m_current
IOVContainer::const_iterator m_current
Definition: IOVProxy.h:60
cond::persistency::IOVProxy::operator=
IOVProxy & operator=(const IOVProxy &rhs)
Definition: IOVProxy.cc:127
cond::Iov_t::payloadId
Hash payloadId
Definition: Types.h:55
cond::persistency::IOVProxy::loadedGroup
std::pair< cond::Time_t, cond::Time_t > loadedGroup() const
Definition: IOVProxy.cc:413
cond::persistency::IOVComp
Definition: IOVProxy.cc:11
cond::Iov_t::since
Time_t since
Definition: Types.h:53
cond::Time_t
unsigned long long Time_t
Definition: Time.h:14
cond::Iov_t::clear
virtual void clear()
Definition: Types.cc:10
cond::persistency::IOVArray::size
size_t size() const
Definition: IOVProxy.cc:97
cond::persistency::IOVProxy::m_data
std::shared_ptr< IOVProxyData > m_data
Definition: IOVProxy.h:164
cond::time::MAX_VAL
const Time_t MAX_VAL(std::numeric_limits< Time_t >::max())
cond::persistency::IOVProxy::numberOfQueries
size_t numberOfQueries() const
Definition: IOVProxy.cc:411
cond::Tag_t
Definition: Types.h:58
cond::persistency::IOVArray::Iterator::operator*
cond::Iov_t operator*()
Definition: IOVProxy.cc:43
cond::persistency::IOVProxy::IOVProxy
IOVProxy()
Definition: IOVProxy.cc:121
cond::persistency::IOVArray::Iterator::m_parent
const IOVArray * m_parent
Definition: IOVProxy.h:61
cond::persistency::IOVArray::Iterator
Definition: IOVProxy.h:37
cond::persistency::IOVProxy::sequenceSize
int sequenceSize() const
Definition: IOVProxy.cc:403
HLTMuonOfflineAnalyzer_cff.destination
destination
Definition: HLTMuonOfflineAnalyzer_cff.py:50
cond::persistency::IOVArray::IOVArray
IOVArray()
Definition: IOVProxy.cc:77
cond::persistency::IOVProxyData::numberOfQueries
size_t numberOfQueries
Definition: IOVProxy.cc:118
heppy_batch.val
val
Definition: heppy_batch.py:351
cond::persistency::IOVArray::Iterator::operator++
Iterator & operator++()
Definition: IOVProxy.cc:56
cond::persistency::IOVProxyData::cacheInitialized
bool cacheInitialized
Definition: IOVProxy.cc:114
cond::persistency::IOVProxy::reset
void reset()
Definition: IOVProxy.cc:240
cond::persistency::IOVArray::isEmpty
bool isEmpty() const
Definition: IOVProxy.cc:100
cond::persistency::IOVProxy::checkTransaction
void checkTransaction(const std::string &ctx) const
Definition: IOVProxy.cc:289
cond::persistency::IOVArray::Iterator::operator=
Iterator & operator=(const Iterator &rhs)
Definition: IOVProxy.cc:35
cond::persistency::throwException
void throwException(const std::string &message, const std::string &methodName)
Definition: Exception.cc:12
filterCSVwithJSON.target
target
Definition: filterCSVwithJSON.py:32
cond::persistency::IOVProxy::fetchSequence
void fetchSequence(cond::Time_t lowerGroup, cond::Time_t higherGroup)
Definition: IOVProxy.cc:296
cond::Iov_t
Definition: Types.h:47
cond::persistency::IOVArray::tagInfo
const cond::Tag_t & tagInfo() const
Definition: IOVProxy.cc:89
cond::persistency::IOVProxyData
Definition: IOVProxy.cc:104
cond::persistency::IOVArray::m_tagInfo
cond::Tag_t m_tagInfo
Definition: IOVProxy.h:88
cond::persistency::IOVContainer
std::vector< std::tuple< cond::Time_t, cond::Hash > > IOVContainer
Definition: IOVProxy.h:25
dummy
Definition: DummySelector.h:38
cond::persistency::IOVArray::Iterator::operator==
bool operator==(const Iterator &rhs) const
Definition: IOVProxy.cc:67
cond::TagInfo_t
Definition: Types.h:69
ntuplemaker.time
time
Definition: ntuplemaker.py:310
cond::persistency::IOVProxyData::iovSequence
IOVContainer iovSequence
Definition: IOVProxy.cc:116
cond::persistency::IOVProxy::tagInfo
cond::Tag_t tagInfo() const
Definition: IOVProxy.cc:247
class-composition.parent
parent
Definition: class-composition.py:88
JetPartonCorrections_cff.tagName
tagName
Definition: JetPartonCorrections_cff.py:12
cond::time::sinceGroupSize
Time_t sinceGroupSize(TimeType tp)
Definition: Time.cc:56
cond::persistency::IOVProxy::m_session
std::shared_ptr< SessionImpl > m_session
Definition: IOVProxy.h:165
cond::persistency::IOVArray::Iterator::operator!=
bool operator!=(const Iterator &rhs) const
Definition: IOVProxy.cc:75
GetRecoTauVFromDQM_MC_cff.next
next
Definition: GetRecoTauVFromDQM_MC_cff.py:31
cond::persistency::IOVArray::Iterator::Iterator
Iterator()
Definition: IOVProxy.cc:28