Integration/plugins/ESTestProducers.cc

0001 #include "FWCore/Framework/interface/DataKey.h"
0002 #include "FWCore/Framework/interface/ESProductResolverProvider.h"
0003 #include "FWCore/Framework/interface/ESProductResolverTemplate.h"
0004 #include "FWCore/Framework/interface/ESProducer.h"
0005 #include "FWCore/Framework/interface/ESProductHost.h"
0006 #include "FWCore/Framework/interface/ESModuleProducesInfo.h"
0007 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0008 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0009 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0010 #include "FWCore/Integration/interface/ESTestData.h"
0011 #include "FWCore/Integration/interface/ESTestRecords.h"
0012 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0013 #include "FWCore/Framework/interface/ModuleFactory.h"
0014 #include "FWCore/Utilities/interface/Exception.h"
0015 #include "FWCore/Utilities/interface/ReusableObjectHolder.h"
0016
0017 #include <memory>
0018 #include <vector>
0019
0020 namespace edmtest {
0021
0022   class ESTestProducerA : public edm::ESProducer {
0023   public:
0024     ESTestProducerA(edm::ParameterSet const&);
0025     std::unique_ptr<ESTestDataA> produce(ESTestRecordA const&);
0026
0027   private:
0028     int value_;
0029   };
0030
0031   ESTestProducerA::ESTestProducerA(edm::ParameterSet const&) : value_(0) { setWhatProduced(this); }
0032
0033   std::unique_ptr<ESTestDataA> ESTestProducerA::produce(ESTestRecordA const& rec) {
0034     ++value_;
0035     return std::make_unique<ESTestDataA>(value_);
0036   }
0037
0038   // ---------------------------------------------------------------------
0039
0040   // This class is used to test ESProductHost
0041   class ESTestProducerBUsingHost : public edm::ESProducer {
0042   public:
0043     ESTestProducerBUsingHost(edm::ParameterSet const&);
0044     // Must use shared_ptr if using ReusableObjectHolder
0045     std::shared_ptr<ESTestDataB> produce(ESTestRecordB const&);
0046
0047   private:
0048     using HostType = edm::ESProductHost<ESTestDataB,
0049                                         ESTestRecordC,
0050                                         ESTestRecordD,
0051                                         ESTestRecordE,
0052                                         ESTestRecordF,
0053                                         ESTestRecordG,
0054                                         ESTestRecordH>;
0055
0056     edm::ReusableObjectHolder<HostType> holder_;
0057   };
0058
0059   ESTestProducerBUsingHost::ESTestProducerBUsingHost(edm::ParameterSet const&) { setWhatProduced(this); }
0060
0061   std::shared_ptr<ESTestDataB> ESTestProducerBUsingHost::produce(ESTestRecordB const& record) {
0062     auto host = holder_.makeOrGet([]() { return new HostType(100, 1000); });
0063
0064     // Test that the numberOfRecordTypes and index functions are working properly
0065     if (host->numberOfRecordTypes() != 6 || host->index<ESTestRecordC>() != 0 || host->index<ESTestRecordD>() != 1 ||
0066         host->index<ESTestRecordE>() != 2 || host->index<ESTestRecordF>() != 3 || host->index<ESTestRecordG>() != 4 ||
0067         host->index<ESTestRecordH>() != 5) {
0068       throw cms::Exception("TestError") << "Either function numberOfRecordTypes or index returns incorrect value";
0069     }
0070
0071     host->ifRecordChanges<ESTestRecordC>(record, [h = host.get()](auto const& rec) { ++h->value(); });
0072
0073     ++host->value();
0074     return host;
0075   }
0076
0077   // ---------------------------------------------------------------------
0078
0079   class TestESProductResolverTemplateJ : public edm::eventsetup::ESProductResolverTemplate<ESTestRecordJ, ESTestDataJ> {
0080   public:
0081     TestESProductResolverTemplateJ(std::vector<unsigned int> const* expectedCacheIds)
0082         : testDataJ_(1), expectedCacheIds_(expectedCacheIds) {}
0083
0084   private:
0085     const ESTestDataJ* make(const ESTestRecordJ& record, const edm::eventsetup::DataKey& key) override {
0086       ESTestRecordK recordK = record.getRecord<ESTestRecordK>();
0087       // Note that this test only reliably works when running with a
0088       // single IOV at a time and a single stream. This test module
0089       // should not be configured with expected values in other cases.
0090       if (index_ < expectedCacheIds_->size() && recordK.cacheIdentifier() != expectedCacheIds_->at(index_)) {
0091         throw cms::Exception("TestError") << "TestESProductResolverTemplateJ::make, unexpected cacheIdentifier";
0092       }
0093       ++index_;
0094       return &testDataJ_;
0095     }
0096
0097     void invalidateCache() override {}
0098     void const* getAfterPrefetchImpl() const override { return &testDataJ_; }
0099
0100     ESTestDataJ testDataJ_;
0101     std::vector<unsigned> const* expectedCacheIds_;
0102     unsigned int index_ = 0;
0103   };
0104
0105   class ESTestESProductResolverProviderJ : public edm::eventsetup::ESProductResolverProvider {
0106   public:
0107     ESTestESProductResolverProviderJ(edm::ParameterSet const&);
0108
0109     static void fillDescriptions(edm::ConfigurationDescriptions&);
0110
0111     std::vector<edm::eventsetup::ESModuleProducesInfo> producesInfo() const override;
0112
0113   private:
0114     KeyedResolversVector registerResolvers(const edm::eventsetup::EventSetupRecordKey&, unsigned int iovIndex) override;
0115
0116     std::vector<std::shared_ptr<TestESProductResolverTemplateJ>> resolvers_;
0117     std::vector<unsigned> expectedCacheIds_;
0118   };
0119
0120   ESTestESProductResolverProviderJ::ESTestESProductResolverProviderJ(edm::ParameterSet const& pset)
0121       : expectedCacheIds_(pset.getUntrackedParameter<std::vector<unsigned int>>("expectedCacheIds")) {
0122     usingRecord<ESTestRecordJ>();
0123   }
0124
0125   void ESTestESProductResolverProviderJ::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0126     edm::ParameterSetDescription desc;
0127     std::vector<unsigned int> emptyDefaultVector;
0128     desc.addUntracked<std::vector<unsigned int>>("expectedCacheIds", emptyDefaultVector);
0129     descriptions.addDefault(desc);
0130   }
0131
0132   edm::eventsetup::ESProductResolverProvider::KeyedResolversVector ESTestESProductResolverProviderJ::registerResolvers(
0133       const edm::eventsetup::EventSetupRecordKey& iRecord, unsigned int iovIndex) {
0134     KeyedResolversVector keyedResolversVector;
0135     while (iovIndex >= resolvers_.size()) {
0136       resolvers_.push_back(std::make_shared<TestESProductResolverTemplateJ>(&expectedCacheIds_));
0137     }
0138     edm::eventsetup::DataKey dataKey(edm::eventsetup::DataKey::makeTypeTag<ESTestDataJ>(), "");
0139     keyedResolversVector.emplace_back(dataKey, resolvers_[iovIndex]);
0140     return keyedResolversVector;
0141   }
0142
0143   std::vector<edm::eventsetup::ESModuleProducesInfo> ESTestESProductResolverProviderJ::producesInfo() const {
0144     std::vector<edm::eventsetup::ESModuleProducesInfo> producesInfo;
0145     producesInfo.emplace_back(edm::eventsetup::EventSetupRecordKey::makeKey<ESTestRecordJ>(),
0146                               edm::eventsetup::DataKey(edm::eventsetup::DataKey::makeTypeTag<ESTestDataJ>(), ""),
0147                               0);
0148     return producesInfo;
0149   }
0150 }  // namespace edmtest
0151
0152 namespace edm::test {
0153   namespace other {
0154     class ESTestProducerA : public edm::ESProducer {
0155     public:
0156       ESTestProducerA(edm::ParameterSet const& pset) : value_(pset.getParameter<int>("valueOther")) {
0157         setWhatProduced(this);
0158       }
0159       std::optional<edmtest::ESTestDataA> produce(ESTestRecordA const& rec) {
0160         ++value_;
0161         return edmtest::ESTestDataA(value_);
0162       }
0163
0164     private:
0165       int value_;
0166     };
0167   }  // namespace other
0168   namespace cpu {
0169     class ESTestProducerA : public edm::ESProducer {
0170     public:
0171       ESTestProducerA(edm::ParameterSet const& pset) : value_(pset.getParameter<int>("valueCpu")) {
0172         setWhatProduced(this);
0173       }
0174       std::optional<edmtest::ESTestDataA> produce(ESTestRecordA const& rec) {
0175         ++value_;
0176         return edmtest::ESTestDataA(value_);
0177       }
0178
0179     private:
0180       int value_;
0181     };
0182   }  // namespace cpu
0183 }  // namespace edm::test
0184
0185 using namespace edmtest;
0186 DEFINE_FWK_EVENTSETUP_MODULE(ESTestProducerA);
0187 DEFINE_FWK_EVENTSETUP_MODULE(ESTestProducerBUsingHost);
0188 DEFINE_FWK_EVENTSETUP_MODULE(ESTestESProductResolverProviderJ);
0189 DEFINE_FWK_EVENTSETUP_MODULE(edm::test::other::ESTestProducerA);
0190 DEFINE_FWK_EVENTSETUP_MODULE(edm::test::cpu::ESTestProducerA);