Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-04-19 02:16:35 

0001 
0002 /*----------------------------------------------------------------------
0003 
0004 Toy EDProducers of Ints for testing purposes only.
0005 
0006 ----------------------------------------------------------------------*/
0007 
0008 #ifdef __clang__
0009 #pragma GCC diagnostic ignored "-Wc++20-extensions"
0010 #endif
0011 
0012 #include "DataFormats/Common/interface/Handle.h"
0013 #include "DataFormats/Common/interface/TriggerResults.h"
0014 #include "DataFormats/TestObjects/interface/ToyProducts.h"
0015 //
0016 #include "FWCore/Framework/interface/stream/EDProducer.h"
0017 #include "FWCore/Framework/interface/global/EDProducer.h"
0018 #include "FWCore/Framework/interface/limited/EDProducer.h"
0019 #include "FWCore/Framework/interface/one/EDProducer.h"
0020 #include "FWCore/Framework/interface/Event.h"
0021 #include "FWCore/Framework/interface/MakerMacros.h"
0022 #include "FWCore/Framework/interface/ProcessBlock.h"
0023 #include "FWCore/Framework/interface/GetterOfProducts.h"
0024 #include "FWCore/Framework/interface/TypeMatch.h"
0025 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0026 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0027 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0028 #include "FWCore/Utilities/interface/EDMException.h"
0029 #include "FWCore/Utilities/interface/InputTag.h"
0030 #include "FWCore/Utilities/interface/transform.h"
0031 //
0032 #include <cassert>
0033 #include <string>
0034 #include <vector>
0035 #include <unistd.h>
0036 
0037 namespace edmtest {
0038 
0039   //--------------------------------------------------------------------
0040   //
0041   // Int producers
0042   //
0043   //--------------------------------------------------------------------
0044 
0045   //--------------------------------------------------------------------
0046   //
0047   // throws an exception.
0048   // Announces an IntProduct but does not produce one;
0049   // every call to FailingProducer::produce throws a cms exception
0050   //
0051   class FailingProducer : public edm::global::EDProducer<> {
0052   public:
0053     explicit FailingProducer(edm::ParameterSet const& /*p*/) { produces<IntProduct>(); }
0054     void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0055   };
0056 
0057   void FailingProducer::produce(edm::StreamID, edm::Event&, edm::EventSetup const&) const {
0058     // We throw an edm exception with a configurable action.
0059     throw edm::Exception(edm::errors::NotFound) << "Intentional 'NotFound' exception for testing purposes\n";
0060   }
0061   //--------------------------------------------------------------------
0062   //
0063   // throws an exception.
0064   // Announces an IntProduct but does not produce one;
0065   // every call to FailingInLumiProducer::produce throws a cms exception
0066   //
0067   class FailingInLumiProducer : public edm::global::EDProducer<edm::BeginLuminosityBlockProducer> {
0068   public:
0069     explicit FailingInLumiProducer(edm::ParameterSet const& /*p*/) {
0070       produces<IntProduct, edm::Transition::BeginLuminosityBlock>();
0071     }
0072     void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0073 
0074     void globalBeginLuminosityBlockProduce(edm::LuminosityBlock&, edm::EventSetup const&) const override;
0075   };
0076 
0077   void FailingInLumiProducer::produce(edm::StreamID, edm::Event&, edm::EventSetup const&) const {}
0078   void FailingInLumiProducer::globalBeginLuminosityBlockProduce(edm::LuminosityBlock&, edm::EventSetup const&) const {
0079     // We throw an edm exception with a configurable action.
0080     throw edm::Exception(edm::errors::NotFound) << "Intentional 'NotFound' exception for testing purposes\n";
0081   }
0082 
0083   //--------------------------------------------------------------------
0084   //
0085   // throws an exception.
0086   // Announces an IntProduct but does not produce one;
0087   // every call to FailingProducer::produce throws a cms exception
0088   //
0089   class FailingInRunProducer : public edm::global::EDProducer<edm::BeginRunProducer> {
0090   public:
0091     explicit FailingInRunProducer(edm::ParameterSet const& /*p*/) { produces<IntProduct, edm::Transition::BeginRun>(); }
0092     void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0093 
0094     void globalBeginRunProduce(edm::Run&, edm::EventSetup const&) const override;
0095   };
0096 
0097   void FailingInRunProducer::produce(edm::StreamID, edm::Event&, edm::EventSetup const&) const {}
0098   void FailingInRunProducer::globalBeginRunProduce(edm::Run&, edm::EventSetup const&) const {
0099     // We throw an edm exception with a configurable action.
0100     throw edm::Exception(edm::errors::NotFound) << "Intentional 'NotFound' exception for testing purposes\n";
0101   }
0102 
0103   //--------------------------------------------------------------------
0104   //
0105   // Announces an IntProduct but does not produce one;
0106   // every call to NonProducer::produce does nothing.
0107   //
0108   class NonProducer : public edm::global::EDProducer<> {
0109   public:
0110     explicit NonProducer(edm::ParameterSet const& /*p*/) { produces<IntProduct>(); }
0111     void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0112   };
0113 
0114   void NonProducer::produce(edm::StreamID, edm::Event&, edm::EventSetup const&) const {}
0115 
0116   //--------------------------------------------------------------------
0117   //
0118   // Produces an IntProduct instance.
0119   //
0120   // NOTE: this really should be a global::EDProducer<> but for testing we use stream
0121   class IntProducer : public edm::stream::EDProducer<> {
0122   public:
0123     explicit IntProducer(edm::ParameterSet const& p)
0124         : token_{produces<IntProduct>()}, value_(p.getParameter<int>("ivalue")) {}
0125     void produce(edm::Event& e, edm::EventSetup const& c) override;
0126 
0127     static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0128       edm::ParameterSetDescription desc;
0129       desc.add<int>("ivalue");
0130       descriptions.addDefault(desc);
0131     }
0132 
0133   private:
0134     edm::EDPutTokenT<IntProduct> token_;
0135     int value_;
0136   };
0137 
0138   void IntProducer::produce(edm::Event& e, edm::EventSetup const&) {
0139     // EventSetup is not used.
0140     e.emplace(token_, value_);
0141   }
0142 
0143   //--------------------------------------------------------------------
0144   //
0145   // Produces an IntProduct instance.
0146   //
0147   class IntOneSharedProducer : public edm::one::EDProducer<edm::one::SharedResources> {
0148   public:
0149     explicit IntOneSharedProducer(edm::ParameterSet const& p) : value_(p.getParameter<int>("ivalue")) {
0150       produces<IntProduct>();
0151       for (auto const& r : p.getUntrackedParameter<std::vector<std::string>>("resourceNames")) {
0152         usesResource(r);
0153       }
0154     }
0155     explicit IntOneSharedProducer(int i) : value_(i) {
0156       produces<IntProduct>();
0157       usesResource("IntOneShared");
0158     }
0159     void produce(edm::Event& e, edm::EventSetup const& c) override;
0160 
0161     static void fillDescriptions(edm::ConfigurationDescriptions& iConfig) {
0162       edm::ParameterSetDescription desc;
0163       desc.add<int>("ivalue");
0164       desc.addUntracked<std::vector<std::string>>("resourceNames", std::vector<std::string>{});
0165 
0166       iConfig.addDefault(desc);
0167     }
0168 
0169   private:
0170     int value_;
0171   };
0172 
0173   void IntOneSharedProducer::produce(edm::Event& e, edm::EventSetup const&) {
0174     // EventSetup is not used.
0175     e.put(std::make_unique<IntProduct>(value_));
0176   }
0177 
0178   //--------------------------------------------------------------------
0179   //
0180   // Produces an IntProduct instance.
0181   //
0182   //
0183   class BusyWaitIntProducer : public edm::global::EDProducer<> {
0184   public:
0185     explicit BusyWaitIntProducer(edm::ParameterSet const& p)
0186         : token_{produces<IntProduct>()},
0187           value_(p.getParameter<int>("ivalue")),
0188           iterations_(p.getParameter<unsigned int>("iterations")),
0189           pi_(std::acos(-1)),
0190           lumiNumberToThrow_(p.getParameter<unsigned int>("lumiNumberToThrow")) {}
0191 
0192     void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0193 
0194     static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
0195 
0196   private:
0197     const edm::EDPutTokenT<IntProduct> token_;
0198     const int value_;
0199     const unsigned int iterations_;
0200     const double pi_;
0201     const unsigned int lumiNumberToThrow_;
0202   };
0203 
0204   void BusyWaitIntProducer::produce(edm::StreamID, edm::Event& e, edm::EventSetup const&) const {
0205     double sum = 0.;
0206     const double stepSize = pi_ / iterations_;
0207     for (unsigned int i = 0; i < iterations_; ++i) {
0208       sum += stepSize * cos(i * stepSize);
0209     }
0210 
0211     e.emplace(token_, value_ + sum);
0212 
0213     if (e.luminosityBlock() == lumiNumberToThrow_) {
0214       throw cms::Exception("Test");
0215     }
0216   }
0217 
0218   void BusyWaitIntProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0219     edm::ParameterSetDescription desc;
0220     desc.add<int>("ivalue");
0221     desc.add<unsigned int>("iterations");
0222     desc.add<unsigned int>("lumiNumberToThrow", 0);
0223     descriptions.addDefault(desc);
0224   }
0225 
0226   //--------------------------------------------------------------------
0227   class BusyWaitIntLimitedProducer : public edm::limited::EDProducer<> {
0228   public:
0229     explicit BusyWaitIntLimitedProducer(edm::ParameterSet const& p)
0230         : edm::limited::EDProducerBase(p),
0231           edm::limited::EDProducer<>(p),
0232           token_{produces<IntProduct>()},
0233           value_(p.getParameter<int>("ivalue")),
0234           iterations_(p.getParameter<unsigned int>("iterations")),
0235           pi_(std::acos(-1)) {}
0236 
0237     void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0238 
0239   private:
0240     const edm::EDPutTokenT<IntProduct> token_;
0241     const int value_;
0242     const unsigned int iterations_;
0243     const double pi_;
0244     mutable std::atomic<unsigned int> reentrancy_{0};
0245   };
0246 
0247   void BusyWaitIntLimitedProducer::produce(edm::StreamID, edm::Event& e, edm::EventSetup const&) const {
0248     auto v = ++reentrancy_;
0249     if (v > concurrencyLimit()) {
0250       --reentrancy_;
0251       throw cms::Exception("NotLimited", "produce called to many times concurrently.");
0252     }
0253 
0254     double sum = 0.;
0255     const double stepSize = pi_ / iterations_;
0256     for (unsigned int i = 0; i < iterations_; ++i) {
0257       sum += stepSize * cos(i * stepSize);
0258     }
0259 
0260     e.emplace(token_, value_ + sum);
0261     --reentrancy_;
0262   }
0263 
0264   //--------------------------------------------------------------------
0265   class BusyWaitIntOneSharedProducer : public edm::one::EDProducer<edm::one::SharedResources> {
0266   public:
0267     explicit BusyWaitIntOneSharedProducer(edm::ParameterSet const& p)
0268         : value_(p.getParameter<int>("ivalue")),
0269           iterations_(p.getParameter<unsigned int>("iterations")),
0270           pi_(std::acos(-1)) {
0271       for (auto const& r : p.getUntrackedParameter<std::vector<std::string>>("resourceNames")) {
0272         usesResource(r);
0273       }
0274       produces<IntProduct>();
0275     }
0276 
0277     static void fillDescriptions(edm::ConfigurationDescriptions& iConfig) {
0278       edm::ParameterSetDescription desc;
0279       desc.add<int>("ivalue");
0280       desc.add<unsigned int>("iterations");
0281       desc.addUntracked<std::vector<std::string>>("resourceNames", std::vector<std::string>{});
0282 
0283       iConfig.addDefault(desc);
0284     }
0285 
0286     void produce(edm::Event& e, edm::EventSetup const& c) override;
0287 
0288   private:
0289     const int value_;
0290     const unsigned int iterations_;
0291     const double pi_;
0292   };
0293 
0294   void BusyWaitIntOneSharedProducer::produce(edm::Event& e, edm::EventSetup const&) {
0295     double sum = 0.;
0296     const double stepSize = pi_ / iterations_;
0297     for (unsigned int i = 0; i < iterations_; ++i) {
0298       sum += stepSize * cos(i * stepSize);
0299     }
0300 
0301     e.put(std::make_unique<IntProduct>(value_ + sum));
0302   }
0303 
0304   //--------------------------------------------------------------------
0305 
0306   class ConsumingIntProducer : public edm::stream::EDProducer<> {
0307   public:
0308     explicit ConsumingIntProducer(edm::ParameterSet const& p)
0309         : getterOfTriggerResults_(edm::TypeMatch(), this),
0310           token_{produces<IntProduct>()},
0311           value_(p.getParameter<int>("ivalue")) {
0312       // not used, only exists to test PathAndConsumesOfModules
0313       consumes<edm::TriggerResults>(edm::InputTag("TriggerResults"));
0314       callWhenNewProductsRegistered(getterOfTriggerResults_);
0315     }
0316     void produce(edm::Event& e, edm::EventSetup const& c) override;
0317 
0318   private:
0319     edm::GetterOfProducts<edm::TriggerResults> getterOfTriggerResults_;
0320     const edm::EDPutTokenT<IntProduct> token_;
0321     const int value_;
0322   };
0323 
0324   void ConsumingIntProducer::produce(edm::Event& e, edm::EventSetup const&) { e.emplace(token_, value_); }
0325 
0326   //--------------------------------------------------------------------
0327   //
0328   // Produces an IntProduct instance whose value is the event number,
0329   // rather than the value of a configured parameter.
0330   //
0331   class EventNumberIntProducer : public edm::global::EDProducer<> {
0332   public:
0333     explicit EventNumberIntProducer(edm::ParameterSet const&) : token_{produces<UInt64Product>()} {}
0334     void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0335 
0336   private:
0337     const edm::EDPutTokenT<UInt64Product> token_;
0338   };
0339 
0340   void EventNumberIntProducer::produce(edm::StreamID, edm::Event& e, edm::EventSetup const&) const {
0341     // EventSetup is not used.
0342     e.emplace(token_, e.id().event());
0343   }
0344 
0345   //--------------------------------------------------------------------
0346   //
0347   // Produces a TransientIntProduct instance.
0348   //
0349   class TransientIntProducer : public edm::global::EDProducer<> {
0350   public:
0351     explicit TransientIntProducer(edm::ParameterSet const& p)
0352         : token_{produces<TransientIntProduct>()}, value_(p.getParameter<int>("ivalue")) {}
0353     void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0354 
0355   private:
0356     const edm::EDPutTokenT<TransientIntProduct> token_;
0357     const int value_;
0358   };
0359 
0360   void TransientIntProducer::produce(edm::StreamID, edm::Event& e, edm::EventSetup const&) const {
0361     // EventSetup is not used.
0362     e.emplace(token_, value_);
0363   }
0364 
0365   //--------------------------------------------------------------------
0366   //
0367   // Produces a IntProduct instance from a TransientIntProduct
0368   //
0369   class IntProducerFromTransient : public edm::global::EDProducer<> {
0370   public:
0371     explicit IntProducerFromTransient(edm::ParameterSet const&)
0372         : putToken_{produces<IntProduct>()}, getToken_{consumes(edm::InputTag{"TransientThing"})} {}
0373     void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0374 
0375   private:
0376     const edm::EDPutTokenT<IntProduct> putToken_;
0377     const edm::EDGetTokenT<TransientIntProduct> getToken_;
0378   };
0379 
0380   void IntProducerFromTransient::produce(edm::StreamID, edm::Event& e, edm::EventSetup const&) const {
0381     // EventSetup is not used.
0382     auto result = e.getHandle(getToken_);
0383     assert(result);
0384     e.emplace(putToken_, result.product()->value);
0385   }
0386 
0387   //--------------------------------------------------------------------
0388   //
0389   // Produces a TransientIntParent instance.
0390   //
0391   class TransientIntParentProducer : public edm::global::EDProducer<> {
0392   public:
0393     explicit TransientIntParentProducer(edm::ParameterSet const& p)
0394         : token_{produces<TransientIntParent>()}, value_(p.getParameter<int>("ivalue")) {}
0395     void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0396 
0397   private:
0398     const edm::EDPutTokenT<TransientIntParent> token_;
0399     const int value_;
0400   };
0401 
0402   void TransientIntParentProducer::produce(edm::StreamID, edm::Event& e, edm::EventSetup const&) const {
0403     // EventSetup is not used.
0404     e.emplace(token_, value_);
0405   }
0406 
0407   //--------------------------------------------------------------------
0408   //
0409   // Produces a IntProduct instance from a TransientIntParent
0410   //
0411   class IntProducerFromTransientParent : public edm::global::EDProducer<> {
0412   public:
0413     explicit IntProducerFromTransientParent(edm::ParameterSet const& p)
0414         : putToken_{produces<IntProduct>()}, getToken_{consumes(p.getParameter<edm::InputTag>("src"))} {}
0415     void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0416 
0417   private:
0418     const edm::EDPutTokenT<IntProduct> putToken_;
0419     const edm::EDGetTokenT<TransientIntParent> getToken_;
0420   };
0421 
0422   void IntProducerFromTransientParent::produce(edm::StreamID, edm::Event& e, edm::EventSetup const&) const {
0423     // EventSetup is not used.
0424     e.emplace(putToken_, e.get(getToken_).value);
0425   }
0426 
0427   //--------------------------------------------------------------------
0428   //
0429   // Produces an Int16_tProduct instance.
0430   //
0431   class Int16_tProducer : public edm::global::EDProducer<> {
0432   public:
0433     explicit Int16_tProducer(edm::ParameterSet const& p)
0434         : token_{produces<Int16_tProduct>()}, value_(p.getParameter<int>("ivalue")) {}
0435     void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0436 
0437   private:
0438     const edm::EDPutTokenT<Int16_tProduct> token_;
0439     const int16_t value_;
0440   };
0441 
0442   void Int16_tProducer::produce(edm::StreamID, edm::Event& e, edm::EventSetup const&) const {
0443     // EventSetup is not used.
0444     e.emplace(token_, value_);
0445   }
0446 
0447   //
0448   // Produces an IntProduct instance, using an IntProduct as input.
0449   //
0450 
0451   class AddIntsProducer : public edm::global::EDProducer<> {
0452   public:
0453     explicit AddIntsProducer(edm::ParameterSet const& p)
0454         : putToken_{produces<IntProduct>()},
0455           otherPutToken_{produces<IntProduct>("other")},
0456           onlyGetOnEvent_(p.getUntrackedParameter<unsigned int>("onlyGetOnEvent")) {
0457       auto const& labels = p.getParameter<std::vector<edm::InputTag>>("labels");
0458       for (auto const& label : labels) {
0459         tokens_.emplace_back(consumes(label));
0460       }
0461     }
0462     void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0463 
0464     static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0465       edm::ParameterSetDescription desc;
0466       desc.addUntracked<unsigned int>("onlyGetOnEvent", 0u);
0467       desc.add<std::vector<edm::InputTag>>("labels");
0468       descriptions.addDefault(desc);
0469     }
0470 
0471   private:
0472     std::vector<edm::EDGetTokenT<IntProduct>> tokens_;
0473     const edm::EDPutTokenT<IntProduct> putToken_;
0474     const edm::EDPutTokenT<IntProduct> otherPutToken_;
0475     unsigned int onlyGetOnEvent_;
0476   };
0477 
0478   void AddIntsProducer::produce(edm::StreamID, edm::Event& e, edm::EventSetup const&) const {
0479     // EventSetup is not used.
0480     int value = 0;
0481 
0482     if (onlyGetOnEvent_ == 0u || e.eventAuxiliary().event() == onlyGetOnEvent_) {
0483       for (auto const& token : tokens_) {
0484         value += e.get(token).value;
0485       }
0486     }
0487     e.emplace(putToken_, value);
0488     e.emplace(otherPutToken_, value);
0489   }
0490 
0491   //
0492   // Produces an IntProduct instance, using many IntProducts as input.
0493   //
0494 
0495   class AddAllIntsProducer : public edm::global::EDProducer<> {
0496   public:
0497     explicit AddAllIntsProducer(edm::ParameterSet const& p) : putToken_{produces()} {
0498       getter_ = edm::GetterOfProducts<IntProduct>(edm::TypeMatch(), this);
0499       callWhenNewProductsRegistered(*getter_);
0500     }
0501     void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0502 
0503     static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0504       edm::ParameterSetDescription desc;
0505       descriptions.addDefault(desc);
0506     }
0507 
0508   private:
0509     const edm::EDPutTokenT<int> putToken_;
0510     std::optional<edm::GetterOfProducts<IntProduct>> getter_;
0511   };
0512 
0513   void AddAllIntsProducer::produce(edm::StreamID, edm::Event& e, edm::EventSetup const&) const {
0514     std::vector<edm::Handle<IntProduct>> ints;
0515     getter_->fillHandles(e, ints);
0516 
0517     int value = 0;
0518     for (auto const& i : ints) {
0519       value += i->value;
0520     }
0521 
0522     e.emplace(putToken_, value);
0523   }
0524 
0525   //
0526   // Produces multiple IntProduct products
0527   //
0528 
0529   class ManyIntProducer : public edm::global::EDProducer<> {
0530   public:
0531     explicit ManyIntProducer(edm::ParameterSet const& p)
0532         : tokenValues_{vector_transform(
0533               p.getParameter<std::vector<edm::ParameterSet>>("values"),
0534               [this](edm::ParameterSet const& pset) {
0535                 auto const& branchAlias = pset.getParameter<std::string>("branchAlias");
0536                 if (not branchAlias.empty()) {
0537                   return TokenValue{
0538                       produces<IntProduct>(pset.getParameter<std::string>("instance")).setBranchAlias(branchAlias),
0539                       pset.getParameter<int>("value")};
0540                 }
0541                 return TokenValue{produces<IntProduct>(pset.getParameter<std::string>("instance")),
0542                                   pset.getParameter<int>("value")};
0543               })},
0544           transientTokenValues_{vector_transform(
0545               p.getParameter<std::vector<edm::ParameterSet>>("transientValues"),
0546               [this](edm::ParameterSet const& pset) {
0547                 auto const& branchAlias = pset.getParameter<std::string>("branchAlias");
0548                 if (not branchAlias.empty()) {
0549                   return TransientTokenValue{produces<TransientIntProduct>(pset.getParameter<std::string>("instance"))
0550                                                  .setBranchAlias(branchAlias),
0551                                              pset.getParameter<int>("value")};
0552                 }
0553                 return TransientTokenValue{produces<TransientIntProduct>(pset.getParameter<std::string>("instance")),
0554                                            pset.getParameter<int>("value")};
0555               })},
0556           throw_{p.getUntrackedParameter<bool>("throw")} {
0557       tokenValues_.push_back(TokenValue{produces<IntProduct>(), p.getParameter<int>("ivalue")});
0558     }
0559 
0560     static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0561       edm::ParameterSetDescription desc;
0562       desc.add<int>("ivalue");
0563       desc.addUntracked<bool>("throw", false);
0564 
0565       {
0566         edm::ParameterSetDescription pset;
0567         pset.add<std::string>("instance");
0568         pset.add<int>("value");
0569         pset.add<std::string>("branchAlias", "");
0570         desc.addVPSet("values", pset, std::vector<edm::ParameterSet>{});
0571         desc.addVPSet("transientValues", pset, std::vector<edm::ParameterSet>{});
0572       }
0573 
0574       descriptions.addDefault(desc);
0575     }
0576 
0577     void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0578 
0579   private:
0580     struct TokenValue {
0581       edm::EDPutTokenT<IntProduct> token;
0582       int value;
0583     };
0584     std::vector<TokenValue> tokenValues_;
0585 
0586     struct TransientTokenValue {
0587       edm::EDPutTokenT<TransientIntProduct> token;
0588       int value;
0589     };
0590     std::vector<TransientTokenValue> transientTokenValues_;
0591 
0592     bool throw_;
0593   };
0594 
0595   void ManyIntProducer::produce(edm::StreamID, edm::Event& e, edm::EventSetup const&) const {
0596     if (throw_) {
0597       throw edm::Exception(edm::errors::NotFound) << "Intentional 'NotFound' exception for testing purposes\n";
0598     }
0599 
0600     // EventSetup is not used.
0601     for (auto const& tv : tokenValues_) {
0602       e.emplace(tv.token, tv.value);
0603     }
0604     for (auto const& tv : transientTokenValues_) {
0605       e.emplace(tv.token, tv.value);
0606     }
0607   }
0608 
0609   //
0610   // Produces multiple IntProduct products based on other products
0611   //
0612 
0613   class ManyIntWhenRegisteredProducer : public edm::global::EDProducer<> {
0614   public:
0615     explicit ManyIntWhenRegisteredProducer(edm::ParameterSet const& p)
0616         : sourceLabel_(p.getParameter<std::string>("src")) {
0617       callWhenNewProductsRegistered([=, this](edm::BranchDescription const& iBranch) {
0618         if (iBranch.moduleLabel() == sourceLabel_) {
0619           if (iBranch.branchType() != edm::InEvent) {
0620             throw edm::Exception(edm::errors::UnimplementedFeature)
0621                 << "ManyIntWhenRegisteredProducer supports only event branches";
0622           }
0623 
0624           this->tokens_.push_back(
0625               Tokens{this->consumes<IntProduct>(
0626                          edm::InputTag{iBranch.moduleLabel(), iBranch.productInstanceName(), iBranch.processName()}),
0627                      this->produces<IntProduct>(iBranch.productInstanceName())});
0628         }
0629       });
0630     }
0631 
0632     static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0633       edm::ParameterSetDescription desc;
0634       desc.add<std::string>("src");
0635       descriptions.addDefault(desc);
0636     }
0637 
0638     void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override;
0639 
0640   private:
0641     struct Tokens {
0642       edm::EDGetTokenT<IntProduct> get;
0643       edm::EDPutTokenT<IntProduct> put;
0644     };
0645 
0646     std::string sourceLabel_;
0647     std::vector<Tokens> tokens_;
0648   };
0649 
0650   void ManyIntWhenRegisteredProducer::produce(edm::StreamID, edm::Event& e, edm::EventSetup const&) const {
0651     for (auto const& toks : tokens_) {
0652       e.emplace(toks.put, e.get(toks.get));
0653     }
0654   };
0655 
0656   //--------------------------------------------------------------------
0657 
0658   class NonEventIntProducer : public edm::global::EDProducer<edm::Accumulator,
0659                                                              edm::BeginRunProducer,
0660                                                              edm::BeginLuminosityBlockProducer,
0661                                                              edm::EndLuminosityBlockProducer,
0662                                                              edm::EndRunProducer,
0663                                                              edm::BeginProcessBlockProducer,
0664                                                              edm::EndProcessBlockProducer,
0665                                                              edm::InputProcessBlockCache<>> {
0666   public:
0667     explicit NonEventIntProducer(edm::ParameterSet const& p)
0668         : bpbToken_{produces<IntProduct, edm::Transition::BeginProcessBlock>("beginProcessBlock")},
0669           brToken_{produces<IntProduct, edm::Transition::BeginRun>("beginRun")},
0670           blToken_{produces<IntProduct, edm::Transition::BeginLuminosityBlock>("beginLumi")},
0671           elToken_{produces<IntProduct, edm::Transition::EndLuminosityBlock>("endLumi")},
0672           erToken_{produces<IntProduct, edm::Transition::EndRun>("endRun")},
0673           epbToken_{produces<IntProduct, edm::Transition::EndProcessBlock>("endProcessBlock")},
0674           value_(p.getParameter<int>("ivalue")),
0675           sleepTime_(p.getParameter<unsigned int>("sleepTime")),
0676           bpbExpect_{p.getUntrackedParameter<int>("expectBeginProcessBlock")},
0677           brExpect_{p.getUntrackedParameter<int>("expectBeginRun")},
0678           blExpect_{p.getUntrackedParameter<int>("expectBeginLuminosityBlock")},
0679           elExpect_{p.getUntrackedParameter<int>("expectEndLuminosityBlock")},
0680           erExpect_{p.getUntrackedParameter<int>("expectEndRun")},
0681           epbExpect_{p.getUntrackedParameter<int>("expectEndProcessBlock")},
0682           aipbExpect_{p.getUntrackedParameter<int>("expectAccessInputProcessBlock")} {
0683       {
0684         auto tag = p.getParameter<edm::InputTag>("consumesBeginProcessBlock");
0685         if (not tag.label().empty()) {
0686           bpbGet_ = consumes<edm::InProcess>(tag);
0687         }
0688       }
0689       {
0690         auto tag = p.getParameter<edm::InputTag>("consumesBeginRun");
0691         if (not tag.label().empty()) {
0692           brGet_ = consumes<edm::InRun>(tag);
0693         }
0694       }
0695       {
0696         auto tag = p.getParameter<edm::InputTag>("consumesBeginLuminosityBlock");
0697         if (not tag.label().empty()) {
0698           blGet_ = consumes<edm::InLumi>(tag);
0699         }
0700       }
0701       {
0702         auto tag = p.getParameter<edm::InputTag>("consumesEndLuminosityBlock");
0703         if (not tag.label().empty()) {
0704           elGet_ = consumes<edm::InLumi>(tag);
0705         }
0706       }
0707       {
0708         auto tag = p.getParameter<edm::InputTag>("consumesEndRun");
0709         if (not tag.label().empty()) {
0710           erGet_ = consumes<edm::InRun>(tag);
0711         }
0712       }
0713       {
0714         auto tag = p.getParameter<edm::InputTag>("consumesEndProcessBlock");
0715         if (not tag.label().empty()) {
0716           epbGet_ = consumes<edm::InProcess>(tag);
0717         }
0718       }
0719       {
0720         auto tag = p.getParameter<edm::InputTag>("consumesAccessInputProcessBlock");
0721         if (not tag.label().empty()) {
0722           aipbGet_ = consumes<edm::InProcess>(tag);
0723         }
0724       }
0725     }
0726     void accumulate(edm::StreamID iID, edm::Event const& e, edm::EventSetup const& c) const override;
0727     void beginProcessBlockProduce(edm::ProcessBlock&) override;
0728     void endProcessBlockProduce(edm::ProcessBlock&) override;
0729     void globalBeginRunProduce(edm::Run& e, edm::EventSetup const&) const override;
0730     void globalEndRunProduce(edm::Run& e, edm::EventSetup const&) const override;
0731     void globalBeginLuminosityBlockProduce(edm::LuminosityBlock& e, edm::EventSetup const&) const override;
0732     void globalEndLuminosityBlockProduce(edm::LuminosityBlock& e, edm::EventSetup const&) const override;
0733     void accessInputProcessBlock(edm::ProcessBlock const&) override;
0734 
0735     static void fillDescriptions(edm::ConfigurationDescriptions& conf) {
0736       edm::ParameterSetDescription desc;
0737       desc.add<int>("ivalue", 0);
0738       desc.add<unsigned int>("sleepTime", 0);
0739       desc.add<edm::InputTag>("consumesBeginProcessBlock", {});
0740       desc.addUntracked<int>("expectBeginProcessBlock", 0);
0741       desc.add<edm::InputTag>("consumesEndProcessBlock", {});
0742       desc.addUntracked<int>("expectEndProcessBlock", 0);
0743       desc.add<edm::InputTag>("consumesAccessInputProcessBlock", {});
0744       desc.addUntracked<int>("expectAccessInputProcessBlock", 0);
0745       desc.add<edm::InputTag>("consumesBeginRun", {});
0746       desc.addUntracked<int>("expectBeginRun", 0);
0747       desc.add<edm::InputTag>("consumesEndRun", {});
0748       desc.addUntracked<int>("expectEndRun", 0);
0749       desc.add<edm::InputTag>("consumesBeginLuminosityBlock", {});
0750       desc.addUntracked<int>("expectBeginLuminosityBlock", 0);
0751       desc.add<edm::InputTag>("consumesEndLuminosityBlock", {});
0752       desc.addUntracked<int>("expectEndLuminosityBlock", 0);
0753 
0754       conf.addDefault(desc);
0755     }
0756 
0757   private:
0758     void check(IntProduct, int) const;
0759     const edm::EDPutTokenT<IntProduct> bpbToken_;
0760     const edm::EDPutTokenT<IntProduct> brToken_;
0761     const edm::EDPutTokenT<IntProduct> blToken_;
0762     const edm::EDPutTokenT<IntProduct> elToken_;
0763     const edm::EDPutTokenT<IntProduct> erToken_;
0764     const edm::EDPutTokenT<IntProduct> epbToken_;
0765     const int value_;
0766     const unsigned int sleepTime_;
0767     edm::EDGetTokenT<IntProduct> bpbGet_;
0768     edm::EDGetTokenT<IntProduct> brGet_;
0769     edm::EDGetTokenT<IntProduct> blGet_;
0770     edm::EDGetTokenT<IntProduct> elGet_;
0771     edm::EDGetTokenT<IntProduct> erGet_;
0772     edm::EDGetTokenT<IntProduct> epbGet_;
0773     edm::EDGetTokenT<IntProduct> aipbGet_;
0774     const int bpbExpect_;
0775     const int brExpect_;
0776     const int blExpect_;
0777     const int elExpect_;
0778     const int erExpect_;
0779     const int epbExpect_;
0780     const int aipbExpect_;
0781   };
0782 
0783   void NonEventIntProducer::accumulate(edm::StreamID iID, edm::Event const& e, edm::EventSetup const&) const {}
0784   void NonEventIntProducer::beginProcessBlockProduce(edm::ProcessBlock& processBlock) {
0785     if (not bpbGet_.isUninitialized()) {
0786       check(processBlock.get(bpbGet_), bpbExpect_);
0787     }
0788     if (sleepTime_ > 0) {
0789       // These sleeps are here to force modules to run concurrently
0790       // in multi-threaded processes. Otherwise, the modules are so
0791       // fast it is hard to tell whether a module finishes before the
0792       // the Framework starts the next module.
0793       usleep(sleepTime_);
0794     }
0795     processBlock.emplace(bpbToken_, value_);
0796   }
0797   void NonEventIntProducer::endProcessBlockProduce(edm::ProcessBlock& processBlock) {
0798     if (not epbGet_.isUninitialized()) {
0799       check(processBlock.get(epbGet_), epbExpect_);
0800     }
0801     if (sleepTime_ > 0) {
0802       usleep(sleepTime_);
0803     }
0804     processBlock.emplace(epbToken_, value_);
0805   }
0806   void NonEventIntProducer::accessInputProcessBlock(edm::ProcessBlock const& processBlock) {
0807     if (not aipbGet_.isUninitialized()) {
0808       check(processBlock.get(aipbGet_), aipbExpect_);
0809     }
0810     if (sleepTime_ > 0) {
0811       usleep(sleepTime_);
0812     }
0813   }
0814   void NonEventIntProducer::globalBeginRunProduce(edm::Run& r, edm::EventSetup const&) const {
0815     if (not brGet_.isUninitialized()) {
0816       check(r.get(brGet_), brExpect_);
0817     }
0818     if (sleepTime_ > 0) {
0819       usleep(sleepTime_);
0820     }
0821     r.emplace(brToken_, value_);
0822   }
0823   void NonEventIntProducer::globalEndRunProduce(edm::Run& r, edm::EventSetup const&) const {
0824     if (not erGet_.isUninitialized()) {
0825       check(r.get(erGet_), erExpect_);
0826     }
0827     if (sleepTime_ > 0) {
0828       usleep(sleepTime_);
0829     }
0830     r.emplace(erToken_, value_);
0831   }
0832   void NonEventIntProducer::globalBeginLuminosityBlockProduce(edm::LuminosityBlock& l, edm::EventSetup const&) const {
0833     if (not blGet_.isUninitialized()) {
0834       check(l.get(blGet_), blExpect_);
0835     }
0836     if (sleepTime_ > 0) {
0837       usleep(sleepTime_);
0838     }
0839     l.emplace(blToken_, value_);
0840   }
0841   void NonEventIntProducer::globalEndLuminosityBlockProduce(edm::LuminosityBlock& l, edm::EventSetup const&) const {
0842     if (not elGet_.isUninitialized()) {
0843       check(l.get(elGet_), elExpect_);
0844     }
0845     if (sleepTime_ > 0) {
0846       usleep(sleepTime_);
0847     }
0848     l.emplace(elToken_, value_);
0849   }
0850   void NonEventIntProducer::check(IntProduct iProd, int iExpect) const {
0851     if (iExpect != iProd.value) {
0852       throw cms::Exception("BadValue") << "expected " << iExpect << " but got " << iProd.value;
0853     }
0854   }
0855 
0856   //--------------------------------------------------------------------
0857   //
0858   // Produces an IntProduct in ProcessBlock at beginProcessBlock
0859   //
0860   class IntProducerBeginProcessBlock : public edm::global::EDProducer<edm::BeginProcessBlockProducer> {
0861   public:
0862     explicit IntProducerBeginProcessBlock(edm::ParameterSet const& p)
0863         : token_{produces<IntProduct, edm::Transition::BeginProcessBlock>()}, value_(p.getParameter<int>("ivalue")) {}
0864     void produce(edm::StreamID, edm::Event&, edm::EventSetup const&) const override {}
0865     void beginProcessBlockProduce(edm::ProcessBlock&) override;
0866 
0867   private:
0868     edm::EDPutTokenT<IntProduct> token_;
0869     int value_;
0870   };
0871 
0872   void IntProducerBeginProcessBlock::beginProcessBlockProduce(edm::ProcessBlock& processBlock) {
0873     processBlock.emplace(token_, value_);
0874   }
0875 
0876   //--------------------------------------------------------------------
0877   //
0878   // Produces an IntProduct in ProcessBlock at endProcessBlock
0879   //
0880   class IntProducerEndProcessBlock : public edm::global::EDProducer<edm::EndProcessBlockProducer> {
0881   public:
0882     explicit IntProducerEndProcessBlock(edm::ParameterSet const& p)
0883         : token_{produces<IntProduct, edm::Transition::EndProcessBlock>()},
0884           token2_{produces<IntProduct, edm::Transition::EndProcessBlock>("two")},
0885           token3_{produces<IntProduct, edm::Transition::EndProcessBlock>("three")},
0886           token4_{produces<IntProduct, edm::Transition::EndProcessBlock>("four")},
0887           value_(p.getParameter<int>("ivalue")) {}
0888     void produce(edm::StreamID, edm::Event&, edm::EventSetup const&) const override {}
0889     void endProcessBlockProduce(edm::ProcessBlock&) override;
0890 
0891   private:
0892     edm::EDPutTokenT<IntProduct> token_;
0893     edm::EDPutToken token2_;
0894     edm::EDPutTokenT<IntProduct> token3_;
0895     edm::EDPutToken token4_;
0896     int value_;
0897   };
0898 
0899   void IntProducerEndProcessBlock::endProcessBlockProduce(edm::ProcessBlock& processBlock) {
0900     processBlock.emplace(token_, value_);
0901     processBlock.emplace<IntProduct>(token2_, value_ + 2);
0902     processBlock.put(token3_, std::make_unique<IntProduct>(value_ + 3));
0903     processBlock.put(token4_, std::make_unique<IntProduct>(value_ + 4));
0904   }
0905 
0906   //--------------------------------------------------------------------
0907   //
0908   // Produces an TransientIntProduct in ProcessBlock at endProcessBlock
0909   //
0910   class TransientIntProducerEndProcessBlock : public edm::global::EDProducer<edm::EndProcessBlockProducer> {
0911   public:
0912     explicit TransientIntProducerEndProcessBlock(edm::ParameterSet const& p)
0913         : token_{produces<TransientIntProduct, edm::Transition::EndProcessBlock>()},
0914           value_(p.getParameter<int>("ivalue")) {}
0915     void produce(edm::StreamID, edm::Event&, edm::EventSetup const&) const override {}
0916     void endProcessBlockProduce(edm::ProcessBlock&) override;
0917 
0918   private:
0919     edm::EDPutTokenT<TransientIntProduct> token_;
0920     int value_;
0921   };
0922 
0923   void TransientIntProducerEndProcessBlock::endProcessBlockProduce(edm::ProcessBlock& processBlock) {
0924     processBlock.emplace(token_, value_);
0925   }
0926 
0927   //--------------------------------------------------------------------
0928   //
0929   // Produces an IntProduct instance, the module must get run, otherwise an exception is thrown
0930   class MustRunIntProducer : public edm::global::EDProducer<> {
0931   public:
0932     explicit MustRunIntProducer(edm::ParameterSet const& p)
0933         : moduleLabel_{p.getParameter<std::string>("@module_label")},
0934           token_{produces<IntProduct>()},
0935           value_(p.getParameter<int>("ivalue")),
0936           produce_{p.getParameter<bool>("produce")},
0937           mustRunEvent_{p.getParameter<bool>("mustRunEvent")} {}
0938     ~MustRunIntProducer() {
0939       if (not wasRunEndJob_) {
0940         throw cms::Exception("NotRun") << "This module (" << moduleLabel_
0941                                        << ") should have run for endJob transition, but it did not";
0942       }
0943     }
0944     static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0945       edm::ParameterSetDescription desc;
0946       desc.add<int>("ivalue");
0947       desc.add<bool>("produce", true);
0948       desc.add<bool>("mustRunEvent", true)
0949           ->setComment(
0950               "If set to false, the endJob() is still required to be called to check that the module was not deleted "
0951               "early on");
0952       descriptions.addDefault(desc);
0953     }
0954     void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const override {
0955       wasRunEvent_ = true;
0956       if (produce_) {
0957         e.emplace(token_, value_);
0958       }
0959     }
0960     void endJob() override {
0961       wasRunEndJob_ = true;
0962       if (mustRunEvent_ and not wasRunEvent_) {
0963         throw cms::Exception("NotRun") << "This module should have run for event transitions, but it did not";
0964       }
0965     }
0966 
0967   private:
0968     const std::string moduleLabel_;
0969     const edm::EDPutTokenT<IntProduct> token_;
0970     const int value_;
0971     const bool produce_;
0972     const bool mustRunEvent_;
0973     mutable std::atomic<bool> wasRunEndJob_ = false;
0974     mutable std::atomic<bool> wasRunEvent_ = false;
0975   };
0976 }  // namespace edmtest
0977 
0978 namespace edm::test {
0979   namespace other {
0980     class IntProducer : public edm::global::EDProducer<> {
0981     public:
0982       explicit IntProducer(edm::ParameterSet const& p)
0983           : token_{produces()}, value_(p.getParameter<int>("valueOther")) {}
0984       void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const final { e.emplace(token_, value_); }
0985 
0986       static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0987         edm::ParameterSetDescription desc;
0988         desc.add<int>("valueOther");
0989         desc.add<int>("valueCpu");
0990         desc.addUntracked<std::string>("variant", "");
0991 
0992         descriptions.addWithDefaultLabel(desc);
0993       }
0994 
0995     private:
0996       edm::EDPutTokenT<edmtest::IntProduct> token_;
0997       int value_;
0998     };
0999 
1000     class IntTransformer : public edm::global::EDProducer<edm::Transformer> {
1001     public:
1002       explicit IntTransformer(edm::ParameterSet const& p)
1003           : token_{produces()}, value_(p.getParameter<int>("valueOther")) {
1004         registerTransform(token_,
1005                           [](edmtest::ATransientIntProduct const& iV) { return edmtest::IntProduct(iV.value); });
1006       }
1007       void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const final { e.emplace(token_, value_); }
1008 
1009       static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
1010         edm::ParameterSetDescription desc;
1011         desc.add<int>("valueOther");
1012         desc.add<int>("valueCpu");
1013         desc.addUntracked<std::string>("variant", "");
1014 
1015         descriptions.addWithDefaultLabel(desc);
1016       }
1017 
1018     private:
1019       edm::EDPutTokenT<edmtest::ATransientIntProduct> token_;
1020       int value_;
1021     };
1022   }  // namespace other
1023   namespace cpu {
1024     class IntProducer : public edm::global::EDProducer<> {
1025     public:
1026       explicit IntProducer(edm::ParameterSet const& p) : token_{produces()}, value_(p.getParameter<int>("valueCpu")) {}
1027       void produce(edm::StreamID, edm::Event& e, edm::EventSetup const& c) const final { e.emplace(token_, value_); }
1028 
1029       static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
1030         edm::ParameterSetDescription desc;
1031         desc.add<int>("valueOther");
1032         desc.add<int>("valueCpu");
1033         desc.addUntracked<std::string>("variant", "");
1034 
1035         descriptions.addWithDefaultLabel(desc);
1036       }
1037 
1038     private:
1039       edm::EDPutTokenT<edmtest::IntProduct> token_;
1040       int value_;
1041     };
1042     // The idea is that the other::IntTransformer produces an
1043     // additional *transient* data product compared to
1044     // cpu::IntTransformer. The cpu::IntTransformer would be
1045     // functionally equivalent to cpu::IntProducer, so can simply use
1046     // a type alias.
1047     using IntTransformer = IntProducer;
1048   }  // namespace cpu
1049 }  // namespace edm::test
1050 
1051 using edmtest::AddAllIntsProducer;
1052 using edmtest::AddIntsProducer;
1053 using edmtest::BusyWaitIntLimitedProducer;
1054 using edmtest::BusyWaitIntOneSharedProducer;
1055 using edmtest::BusyWaitIntProducer;
1056 using edmtest::ConsumingIntProducer;
1057 using edmtest::EventNumberIntProducer;
1058 using edmtest::FailingProducer;
1059 using edmtest::Int16_tProducer;
1060 using edmtest::IntOneSharedProducer;
1061 using edmtest::IntProducer;
1062 using edmtest::IntProducerBeginProcessBlock;
1063 using edmtest::IntProducerEndProcessBlock;
1064 using edmtest::IntProducerFromTransient;
1065 using edmtest::ManyIntProducer;
1066 using edmtest::ManyIntWhenRegisteredProducer;
1067 using edmtest::NonEventIntProducer;
1068 using edmtest::NonProducer;
1069 using edmtest::TransientIntProducer;
1070 using edmtest::TransientIntProducerEndProcessBlock;
1071 DEFINE_FWK_MODULE(FailingProducer);
1072 DEFINE_FWK_MODULE(edmtest::FailingInLumiProducer);
1073 DEFINE_FWK_MODULE(edmtest::FailingInRunProducer);
1074 DEFINE_FWK_MODULE(NonProducer);
1075 DEFINE_FWK_MODULE(IntProducer);
1076 DEFINE_FWK_MODULE(IntOneSharedProducer);
1077 DEFINE_FWK_MODULE(BusyWaitIntProducer);
1078 DEFINE_FWK_MODULE(BusyWaitIntLimitedProducer);
1079 DEFINE_FWK_MODULE(BusyWaitIntOneSharedProducer);
1080 DEFINE_FWK_MODULE(ConsumingIntProducer);
1081 DEFINE_FWK_MODULE(EventNumberIntProducer);
1082 DEFINE_FWK_MODULE(TransientIntProducer);
1083 DEFINE_FWK_MODULE(IntProducerFromTransient);
1084 DEFINE_FWK_MODULE(edmtest::TransientIntParentProducer);
1085 DEFINE_FWK_MODULE(edmtest::IntProducerFromTransientParent);
1086 DEFINE_FWK_MODULE(Int16_tProducer);
1087 DEFINE_FWK_MODULE(AddIntsProducer);
1088 DEFINE_FWK_MODULE(AddAllIntsProducer);
1089 DEFINE_FWK_MODULE(ManyIntProducer);
1090 DEFINE_FWK_MODULE(ManyIntWhenRegisteredProducer);
1091 DEFINE_FWK_MODULE(NonEventIntProducer);
1092 DEFINE_FWK_MODULE(IntProducerBeginProcessBlock);
1093 DEFINE_FWK_MODULE(IntProducerEndProcessBlock);
1094 DEFINE_FWK_MODULE(TransientIntProducerEndProcessBlock);
1095 DEFINE_FWK_MODULE(edmtest::MustRunIntProducer);
1096 DEFINE_FWK_MODULE(edm::test::other::IntProducer);
1097 DEFINE_FWK_MODULE(edm::test::cpu::IntProducer);
1098 DEFINE_FWK_MODULE(edm::test::other::IntTransformer);
1099 DEFINE_FWK_MODULE(edm::test::cpu::IntTransformer);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!