Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2021-02-14 13:28:28

0001 #include "FWCore/Framework/interface/DataKey.h"
0002 #include "FWCore/Framework/interface/DataProxyProvider.h"
0003 #include "FWCore/Framework/interface/DataProxyTemplate.h"
0004 #include "FWCore/Framework/interface/ESProducer.h"
0005 #include "FWCore/Framework/interface/ESProductHost.h"
0006 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0007 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0008 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0009 #include "FWCore/Integration/interface/ESTestData.h"
0010 #include "FWCore/Integration/interface/ESTestRecords.h"
0011 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0012 #include "FWCore/Framework/interface/ModuleFactory.h"
0013 #include "FWCore/Utilities/interface/Exception.h"
0014 #include "FWCore/Utilities/interface/ReusableObjectHolder.h"
0015 
0016 #include <memory>
0017 #include <vector>
0018 
0019 namespace edmtest {
0020 
0021   class ESTestProducerA : public edm::ESProducer {
0022   public:
0023     ESTestProducerA(edm::ParameterSet const&);
0024     std::unique_ptr<ESTestDataA> produce(ESTestRecordA const&);
0025 
0026   private:
0027     int value_;
0028   };
0029 
0030   ESTestProducerA::ESTestProducerA(edm::ParameterSet const&) : value_(0) { setWhatProduced(this); }
0031 
0032   std::unique_ptr<ESTestDataA> ESTestProducerA::produce(ESTestRecordA const& rec) {
0033     ++value_;
0034     return std::make_unique<ESTestDataA>(value_);
0035   }
0036 
0037   // ---------------------------------------------------------------------
0038 
0039   class ESTestProducerB : public edm::ESProducer {
0040   public:
0041     ESTestProducerB(edm::ParameterSet const&);
0042     std::unique_ptr<ESTestDataB> produce(ESTestRecordB const&);
0043 
0044   private:
0045     int value_;
0046   };
0047 
0048   ESTestProducerB::ESTestProducerB(edm::ParameterSet const&) : value_(0) { setWhatProduced(this); }
0049 
0050   std::unique_ptr<ESTestDataB> ESTestProducerB::produce(ESTestRecordB const& rec) {
0051     ++value_;
0052     return std::make_unique<ESTestDataB>(value_);
0053   }
0054 
0055   // ---------------------------------------------------------------------
0056 
0057   // This class is used to test ESProductHost
0058   class ESTestProducerBUsingHost : public edm::ESProducer {
0059   public:
0060     ESTestProducerBUsingHost(edm::ParameterSet const&);
0061     // Must use shared_ptr if using ReusableObjectHolder
0062     std::shared_ptr<ESTestDataB> produce(ESTestRecordB const&);
0063 
0064   private:
0065     using HostType = edm::ESProductHost<ESTestDataB,
0066                                         ESTestRecordC,
0067                                         ESTestRecordD,
0068                                         ESTestRecordE,
0069                                         ESTestRecordF,
0070                                         ESTestRecordG,
0071                                         ESTestRecordH>;
0072 
0073     edm::ReusableObjectHolder<HostType> holder_;
0074   };
0075 
0076   ESTestProducerBUsingHost::ESTestProducerBUsingHost(edm::ParameterSet const&) { setWhatProduced(this); }
0077 
0078   std::shared_ptr<ESTestDataB> ESTestProducerBUsingHost::produce(ESTestRecordB const& record) {
0079     auto host = holder_.makeOrGet([]() { return new HostType(100, 1000); });
0080 
0081     // Test that the numberOfRecordTypes and index functions are working properly
0082     if (host->numberOfRecordTypes() != 6 || host->index<ESTestRecordC>() != 0 || host->index<ESTestRecordD>() != 1 ||
0083         host->index<ESTestRecordE>() != 2 || host->index<ESTestRecordF>() != 3 || host->index<ESTestRecordG>() != 4 ||
0084         host->index<ESTestRecordH>() != 5) {
0085       throw cms::Exception("TestError") << "Either function numberOfRecordTypes or index returns incorrect value";
0086     }
0087 
0088     host->ifRecordChanges<ESTestRecordC>(record, [h = host.get()](auto const& rec) { ++h->value(); });
0089 
0090     ++host->value();
0091     return host;
0092   }
0093 
0094   // ---------------------------------------------------------------------
0095 
0096   class ESTestProducerC : public edm::ESProducer {
0097   public:
0098     ESTestProducerC(edm::ParameterSet const&);
0099     std::unique_ptr<ESTestDataC> produce(ESTestRecordC const&);
0100 
0101   private:
0102     int value_;
0103   };
0104 
0105   ESTestProducerC::ESTestProducerC(edm::ParameterSet const&) : value_(0) { setWhatProduced(this); }
0106 
0107   std::unique_ptr<ESTestDataC> ESTestProducerC::produce(ESTestRecordC const& rec) {
0108     ++value_;
0109     return std::make_unique<ESTestDataC>(value_);
0110   }
0111 
0112   // ---------------------------------------------------------------------
0113 
0114   class ESTestProducerD : public edm::ESProducer {
0115   public:
0116     ESTestProducerD(edm::ParameterSet const&);
0117     std::unique_ptr<ESTestDataD> produce(ESTestRecordD const&);
0118 
0119   private:
0120     int value_;
0121   };
0122 
0123   ESTestProducerD::ESTestProducerD(edm::ParameterSet const&) : value_(0) { setWhatProduced(this); }
0124 
0125   std::unique_ptr<ESTestDataD> ESTestProducerD::produce(ESTestRecordD const& rec) {
0126     ++value_;
0127     return std::make_unique<ESTestDataD>(value_);
0128   }
0129 
0130   // ---------------------------------------------------------------------
0131 
0132   class ESTestProducerE : public edm::ESProducer {
0133   public:
0134     ESTestProducerE(edm::ParameterSet const&);
0135     std::unique_ptr<ESTestDataE> produce(ESTestRecordE const&);
0136 
0137   private:
0138     int value_;
0139   };
0140 
0141   ESTestProducerE::ESTestProducerE(edm::ParameterSet const&) : value_(0) { setWhatProduced(this); }
0142 
0143   std::unique_ptr<ESTestDataE> ESTestProducerE::produce(ESTestRecordE const& rec) {
0144     ++value_;
0145     return std::make_unique<ESTestDataE>(value_);
0146   }
0147 
0148   // ---------------------------------------------------------------------
0149 
0150   class ESTestProducerF : public edm::ESProducer {
0151   public:
0152     ESTestProducerF(edm::ParameterSet const&);
0153     std::unique_ptr<ESTestDataF> produce(ESTestRecordF const&);
0154 
0155   private:
0156     int value_;
0157   };
0158 
0159   ESTestProducerF::ESTestProducerF(edm::ParameterSet const&) : value_(0) { setWhatProduced(this); }
0160 
0161   std::unique_ptr<ESTestDataF> ESTestProducerF::produce(ESTestRecordF const& rec) {
0162     ++value_;
0163     return std::make_unique<ESTestDataF>(value_);
0164   }
0165 
0166   // ---------------------------------------------------------------------
0167 
0168   class ESTestProducerG : public edm::ESProducer {
0169   public:
0170     ESTestProducerG(edm::ParameterSet const&);
0171     std::unique_ptr<ESTestDataG> produce(ESTestRecordG const&);
0172 
0173   private:
0174     int value_;
0175   };
0176 
0177   ESTestProducerG::ESTestProducerG(edm::ParameterSet const&) : value_(0) { setWhatProduced(this); }
0178 
0179   std::unique_ptr<ESTestDataG> ESTestProducerG::produce(ESTestRecordG const& rec) {
0180     ++value_;
0181     return std::make_unique<ESTestDataG>(value_);
0182   }
0183 
0184   // ---------------------------------------------------------------------
0185 
0186   class ESTestProducerH : public edm::ESProducer {
0187   public:
0188     ESTestProducerH(edm::ParameterSet const&);
0189     std::unique_ptr<ESTestDataH> produce(ESTestRecordH const&);
0190 
0191   private:
0192     int value_;
0193   };
0194 
0195   ESTestProducerH::ESTestProducerH(edm::ParameterSet const&) : value_(0) { setWhatProduced(this); }
0196 
0197   std::unique_ptr<ESTestDataH> ESTestProducerH::produce(ESTestRecordH const& rec) {
0198     ++value_;
0199     return std::make_unique<ESTestDataH>(value_);
0200   }
0201 
0202   // ---------------------------------------------------------------------
0203 
0204   class ESTestProducerI : public edm::ESProducer {
0205   public:
0206     ESTestProducerI(edm::ParameterSet const&);
0207     std::unique_ptr<ESTestDataI> produce(ESTestRecordI const&);
0208 
0209   private:
0210     int value_;
0211   };
0212 
0213   ESTestProducerI::ESTestProducerI(edm::ParameterSet const&) : value_(0) { setWhatProduced(this); }
0214 
0215   std::unique_ptr<ESTestDataI> ESTestProducerI::produce(ESTestRecordI const& rec) {
0216     ++value_;
0217     return std::make_unique<ESTestDataI>(value_);
0218   }
0219 
0220   // ---------------------------------------------------------------------
0221 
0222   class ESTestProducerJ : public edm::ESProducer {
0223   public:
0224     ESTestProducerJ(edm::ParameterSet const&);
0225     std::unique_ptr<ESTestDataJ> produce(ESTestRecordJ const&);
0226 
0227   private:
0228     int value_;
0229   };
0230 
0231   ESTestProducerJ::ESTestProducerJ(edm::ParameterSet const&) : value_(0) { setWhatProduced(this); }
0232 
0233   std::unique_ptr<ESTestDataJ> ESTestProducerJ::produce(ESTestRecordJ const& rec) {
0234     ++value_;
0235     return std::make_unique<ESTestDataJ>(value_);
0236   }
0237 
0238   // ---------------------------------------------------------------------
0239 
0240   class ESTestProducerK : public edm::ESProducer {
0241   public:
0242     ESTestProducerK(edm::ParameterSet const&);
0243     std::unique_ptr<ESTestDataK> produce(ESTestRecordK const&);
0244 
0245   private:
0246     int value_;
0247   };
0248 
0249   ESTestProducerK::ESTestProducerK(edm::ParameterSet const&) : value_(0) { setWhatProduced(this); }
0250 
0251   std::unique_ptr<ESTestDataK> ESTestProducerK::produce(ESTestRecordK const& rec) {
0252     ++value_;
0253     return std::make_unique<ESTestDataK>(value_);
0254   }
0255 
0256   // ---------------------------------------------------------------------
0257 
0258   class ESTestProducerAZ : public edm::ESProducer {
0259   public:
0260     ESTestProducerAZ(edm::ParameterSet const&);
0261     std::unique_ptr<ESTestDataA> produceA(ESTestRecordA const&);
0262     std::unique_ptr<ESTestDataZ> produceZ(ESTestRecordZ const&);
0263 
0264   private:
0265     int valueA_;
0266     int valueZ_;
0267   };
0268 
0269   ESTestProducerAZ::ESTestProducerAZ(edm::ParameterSet const&) : valueA_(0), valueZ_(0) {
0270     setWhatProduced(this, &edmtest::ESTestProducerAZ::produceA, edm::es::Label("foo"));
0271     setWhatProduced(this, &edmtest::ESTestProducerAZ::produceZ, edm::es::Label("foo"));
0272   }
0273 
0274   std::unique_ptr<ESTestDataA> ESTestProducerAZ::produceA(ESTestRecordA const& rec) {
0275     ++valueA_;
0276     return std::make_unique<ESTestDataA>(valueA_);
0277   }
0278 
0279   std::unique_ptr<ESTestDataZ> ESTestProducerAZ::produceZ(ESTestRecordZ const& rec) {
0280     ++valueZ_;
0281     return std::make_unique<ESTestDataZ>(valueZ_);
0282   }
0283 
0284   class TestDataProxyTemplateJ : public edm::eventsetup::DataProxyTemplate<ESTestRecordJ, ESTestDataJ> {
0285   public:
0286     TestDataProxyTemplateJ(std::vector<unsigned int> const* expectedCacheIds)
0287         : testDataJ_(1), expectedCacheIds_(expectedCacheIds) {}
0288 
0289   private:
0290     const ESTestDataJ* make(const ESTestRecordJ& record, const edm::eventsetup::DataKey& key) override {
0291       ESTestRecordK recordK = record.getRecord<ESTestRecordK>();
0292       // Note that this test only reliably works when running with a
0293       // single IOV at a time and a single stream. This test module
0294       // should not be configured with expected values in other cases.
0295       if (index_ < expectedCacheIds_->size() && recordK.cacheIdentifier() != expectedCacheIds_->at(index_)) {
0296         throw cms::Exception("TestError") << "TestDataProxyTemplateJ::make, unexpected cacheIdentifier";
0297       }
0298       ++index_;
0299       return &testDataJ_;
0300     }
0301 
0302     void invalidateCache() override {}
0303     void const* getAfterPrefetchImpl() const override { return &testDataJ_; }
0304 
0305     ESTestDataJ testDataJ_;
0306     std::vector<unsigned> const* expectedCacheIds_;
0307     unsigned int index_ = 0;
0308   };
0309 
0310   class ESTestDataProxyProviderJ : public edm::eventsetup::DataProxyProvider {
0311   public:
0312     ESTestDataProxyProviderJ(edm::ParameterSet const&);
0313 
0314     static void fillDescriptions(edm::ConfigurationDescriptions&);
0315 
0316   private:
0317     KeyedProxiesVector registerProxies(const edm::eventsetup::EventSetupRecordKey&, unsigned int iovIndex) override;
0318 
0319     std::vector<std::shared_ptr<TestDataProxyTemplateJ>> proxies_;
0320     std::vector<unsigned> expectedCacheIds_;
0321   };
0322 
0323   ESTestDataProxyProviderJ::ESTestDataProxyProviderJ(edm::ParameterSet const& pset)
0324       : expectedCacheIds_(pset.getUntrackedParameter<std::vector<unsigned int>>("expectedCacheIds")) {
0325     usingRecord<ESTestRecordJ>();
0326   }
0327 
0328   void ESTestDataProxyProviderJ::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0329     edm::ParameterSetDescription desc;
0330     std::vector<unsigned int> emptyDefaultVector;
0331     desc.addUntracked<std::vector<unsigned int>>("expectedCacheIds", emptyDefaultVector);
0332     descriptions.addDefault(desc);
0333   }
0334 
0335   edm::eventsetup::DataProxyProvider::KeyedProxiesVector ESTestDataProxyProviderJ::registerProxies(
0336       const edm::eventsetup::EventSetupRecordKey& iRecord, unsigned int iovIndex) {
0337     KeyedProxiesVector keyedProxiesVector;
0338     while (iovIndex >= proxies_.size()) {
0339       proxies_.push_back(std::make_shared<TestDataProxyTemplateJ>(&expectedCacheIds_));
0340     }
0341     edm::eventsetup::DataKey dataKey(edm::eventsetup::DataKey::makeTypeTag<ESTestDataJ>(), "");
0342     keyedProxiesVector.emplace_back(dataKey, proxies_[iovIndex]);
0343     return keyedProxiesVector;
0344   }
0345 }  // namespace edmtest
0346 
0347 using namespace edmtest;
0348 DEFINE_FWK_EVENTSETUP_MODULE(ESTestProducerA);
0349 DEFINE_FWK_EVENTSETUP_MODULE(ESTestProducerB);
0350 DEFINE_FWK_EVENTSETUP_MODULE(ESTestProducerBUsingHost);
0351 DEFINE_FWK_EVENTSETUP_MODULE(ESTestProducerC);
0352 DEFINE_FWK_EVENTSETUP_MODULE(ESTestProducerD);
0353 DEFINE_FWK_EVENTSETUP_MODULE(ESTestProducerE);
0354 DEFINE_FWK_EVENTSETUP_MODULE(ESTestProducerF);
0355 DEFINE_FWK_EVENTSETUP_MODULE(ESTestProducerG);
0356 DEFINE_FWK_EVENTSETUP_MODULE(ESTestProducerH);
0357 DEFINE_FWK_EVENTSETUP_MODULE(ESTestProducerI);
0358 DEFINE_FWK_EVENTSETUP_MODULE(ESTestProducerJ);
0359 DEFINE_FWK_EVENTSETUP_MODULE(ESTestProducerK);
0360 DEFINE_FWK_EVENTSETUP_MODULE(ESTestProducerAZ);
0361 DEFINE_FWK_EVENTSETUP_MODULE(ESTestDataProxyProviderJ);