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