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