File indexing completed on 2025-04-02 23:19:23
0001 #ifndef CondCore_ESSources_ProductResolver_H
0002 #define CondCore_ESSources_ProductResolver_H
0003
0004 #include <cassert>
0005
0006 #include <memory>
0007 #include <string>
0008 #include <mutex>
0009
0010
0011 #include "FWCore/Framework/interface/ESSourceProductResolverTemplate.h"
0012 #include "FWCore/Framework/interface/DataKey.h"
0013 #include "FWCore/Framework/interface/EventSetupRecordKey.h"
0014
0015 #include "CondCore/CondDB/interface/IOVProxy.h"
0016 #include "CondCore/CondDB/interface/PayloadProxy.h"
0017 #include "CondCore/CondDB/interface/Time.h"
0018 #include "CondCore/CondDB/interface/Types.h"
0019
0020
0021 namespace cond {
0022 template <typename DataT>
0023 struct DefaultInitializer {
0024 void operator()(DataT&) {}
0025 };
0026
0027 template <class RecordT, class DataT, typename Initializer = cond::DefaultInitializer<DataT>>
0028 class ProductResolver : public edm::eventsetup::ESSourceProductResolverTemplate<DataT> {
0029 public:
0030 explicit ProductResolver(std::shared_ptr<cond::persistency::PayloadProxy<DataT>> pdata,
0031 edm::SerialTaskQueue* iQueue,
0032 std::mutex* iMutex)
0033 : edm::eventsetup::ESSourceProductResolverTemplate<DataT>(iQueue, iMutex), m_data{pdata} {}
0034
0035 const ProductResolver& operator=(const ProductResolver&) = delete;
0036
0037
0038
0039
0040
0041
0042 protected:
0043 void prefetch(edm::eventsetup::DataKey const& iKey, edm::EventSetupRecordDetails) final {
0044 m_data->make();
0045 m_initializer(const_cast<DataT&>((*m_data)()));
0046 }
0047
0048 DataT const* fetch() const final { return &(*m_data)(); }
0049
0050 private:
0051 void initializeForNewIOV() override { m_data->initializeForNewIOV(); }
0052
0053
0054
0055 std::shared_ptr<cond::persistency::PayloadProxy<DataT>> m_data;
0056 Initializer m_initializer;
0057 };
0058
0059
0060
0061
0062 class ProductResolverWrapperBase {
0063 public:
0064 typedef std::shared_ptr<cond::persistency::BasePayloadProxy> ProxyP;
0065 typedef std::shared_ptr<edm::eventsetup::ESProductResolver> esResolverP;
0066
0067
0068 typedef std::pair<std::string, std::string> Args;
0069
0070 virtual edm::eventsetup::TypeTag type() const = 0;
0071 virtual ProxyP proxy(unsigned int iovIndex) const = 0;
0072 virtual esResolverP esResolver(unsigned int iovIndex) const = 0;
0073 virtual edm::eventsetup::EventSetupRecordKey recordKey() const = 0;
0074
0075 ProductResolverWrapperBase();
0076
0077 virtual void lateInit(persistency::Session& session,
0078 const std::string& tag,
0079 const boost::posix_time::ptime& snapshotTime,
0080 std::string const& il,
0081 std::string const& cs,
0082 edm::SerialTaskQueue* queue,
0083 std::mutex* mutex) = 0;
0084
0085 virtual void initConcurrentIOVs(unsigned int nConcurrentIOVs) = 0;
0086
0087 void addInfo(std::string const& il, std::string const& cs, std::string const& tag);
0088
0089 virtual ~ProductResolverWrapperBase();
0090
0091 std::string const& label() const { return m_label; }
0092 std::string const& connString() const { return m_connString; }
0093 std::string const& tag() const { return m_tag; }
0094 persistency::IOVProxy& iovProxy() { return m_iovProxy; }
0095 persistency::IOVProxy const& iovProxy() const { return m_iovProxy; }
0096 Iov_t const& currentIov() const { return m_currentIov; }
0097 persistency::Session& session() { return m_session; }
0098 persistency::Session const& session() const { return m_session; }
0099 std::shared_ptr<std::vector<Iov_t>> const& requests() const { return m_requests; }
0100
0101 void setSession(persistency::Session const& v) { m_session = v; }
0102
0103 void loadTag(std::string const& tag);
0104 void loadTag(std::string const& tag, boost::posix_time::ptime const& snapshotTime);
0105 void reload();
0106
0107 ValidityInterval setIntervalFor(Time_t target);
0108 TimeType timeType() const { return m_iovProxy.tagInfo().timeType; }
0109
0110 void setPrintDebug(bool printDebug) { m_printDebug = printDebug; }
0111
0112 private:
0113 std::string m_label;
0114 std::string m_connString;
0115 std::string m_tag;
0116 persistency::IOVProxy m_iovProxy;
0117 Iov_t m_currentIov;
0118 persistency::Session m_session;
0119 std::shared_ptr<std::vector<Iov_t>> m_requests;
0120
0121
0122 bool m_printDebug = false;
0123 };
0124 }
0125
0126
0127
0128
0129 template <class RecordT, class DataT, typename Initializer = cond::DefaultInitializer<DataT>>
0130 class ProductResolverWrapper : public cond::ProductResolverWrapperBase {
0131 public:
0132 typedef ::cond::ProductResolver<RecordT, DataT, Initializer> ProductResolver;
0133
0134
0135 explicit ProductResolverWrapper(const char* source = nullptr) : m_source(source ? source : "") {
0136
0137
0138 m_type = edm::eventsetup::DataKey::makeTypeTag<DataT>();
0139 }
0140
0141
0142 void lateInit(cond::persistency::Session& iSession,
0143 const std::string& tag,
0144 const boost::posix_time::ptime& snapshotTime,
0145 std::string const& il,
0146 std::string const& cs,
0147 edm::SerialTaskQueue* queue,
0148 std::mutex* mutex) override {
0149 setSession(iSession);
0150
0151 loadTag(tag, snapshotTime);
0152
0153
0154 m_proxies.push_back(std::make_shared<cond::persistency::PayloadProxy<DataT>>(
0155 ¤tIov(), &session(), &requests(), m_source.empty() ? (const char*)nullptr : m_source.c_str()));
0156 m_esResolvers.push_back(std::make_shared<ProductResolver>(m_proxies[0], queue, mutex));
0157 addInfo(il, cs, tag);
0158 }
0159
0160 void initConcurrentIOVs(unsigned int nConcurrentIOVs) override {
0161
0162
0163 if (m_proxies.size() != nConcurrentIOVs) {
0164 assert(m_proxies.size() == 1);
0165 auto queue = m_esResolvers.front()->queue();
0166 auto mutex = m_esResolvers.front()->mutex();
0167 for (unsigned int i = 1; i < nConcurrentIOVs; ++i) {
0168 m_proxies.push_back(std::make_shared<cond::persistency::PayloadProxy<DataT>>(
0169 ¤tIov(), &session(), &requests(), m_source.empty() ? (const char*)nullptr : m_source.c_str()));
0170 m_esResolvers.push_back(std::make_shared<ProductResolver>(m_proxies[i], queue, mutex));
0171
0172
0173 m_proxies[i]->initKeyList(*m_proxies[0]);
0174 }
0175 assert(m_proxies.size() == nConcurrentIOVs);
0176 }
0177 assert(m_proxies.size() == m_esResolvers.size());
0178 }
0179
0180 edm::eventsetup::TypeTag type() const override { return m_type; }
0181 ProxyP proxy(unsigned int iovIndex) const override { return m_proxies.at(iovIndex); }
0182 esResolverP esResolver(unsigned int iovIndex) const override { return m_esResolvers.at(iovIndex); }
0183
0184
0185
0186
0187 edm::eventsetup::EventSetupRecordKey recordKey() const final {
0188 return edm::eventsetup::EventSetupRecordKey::makeKey<RecordT>();
0189 }
0190
0191 private:
0192 std::string m_source;
0193 edm::eventsetup::TypeTag m_type;
0194 std::vector<std::shared_ptr<cond::persistency::PayloadProxy<DataT>>> m_proxies;
0195 std::vector<std::shared_ptr<ProductResolver>> m_esResolvers;
0196 };
0197
0198 #endif