Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2025-06-20 01:53:19

0001 #include "FWCore/Framework/interface/maker/WorkerT.h"
0002 #include "FWCore/Framework/interface/EventPrincipal.h"
0003 
0004 #include "FWCore/Framework/interface/one/EDProducerBase.h"
0005 #include "FWCore/Framework/interface/one/EDFilterBase.h"
0006 #include "FWCore/Framework/interface/one/EDAnalyzerBase.h"
0007 #include "FWCore/Framework/interface/one/OutputModuleBase.h"
0008 #include "FWCore/Framework/interface/global/EDProducerBase.h"
0009 #include "FWCore/Framework/interface/global/EDFilterBase.h"
0010 #include "FWCore/Framework/interface/global/EDAnalyzerBase.h"
0011 #include "FWCore/Framework/interface/global/OutputModuleBase.h"
0012 
0013 #include "FWCore/Framework/interface/stream/EDProducerAdaptorBase.h"
0014 #include "FWCore/Framework/interface/stream/EDFilterAdaptorBase.h"
0015 #include "FWCore/Framework/interface/stream/EDAnalyzerAdaptorBase.h"
0016 
0017 #include "FWCore/Framework/interface/limited/EDProducerBase.h"
0018 #include "FWCore/Framework/interface/limited/EDFilterBase.h"
0019 #include "FWCore/Framework/interface/limited/EDAnalyzerBase.h"
0020 #include "FWCore/Framework/interface/limited/OutputModuleBase.h"
0021 
0022 #include "FWCore/ServiceRegistry/interface/ModuleConsumesInfo.h"
0023 
0024 #include <type_traits>
0025 
0026 namespace edm {
0027   namespace workerimpl {
0028     template <typename T>
0029     struct has_stream_functions {
0030       static bool constexpr value = false;
0031     };
0032 
0033     template <>
0034     struct has_stream_functions<edm::global::EDProducerBase> {
0035       static bool constexpr value = true;
0036     };
0037 
0038     template <>
0039     struct has_stream_functions<edm::global::EDFilterBase> {
0040       static bool constexpr value = true;
0041     };
0042 
0043     template <>
0044     struct has_stream_functions<edm::global::EDAnalyzerBase> {
0045       static bool constexpr value = true;
0046     };
0047 
0048     template <>
0049     struct has_stream_functions<edm::limited::EDProducerBase> {
0050       static bool constexpr value = true;
0051     };
0052 
0053     template <>
0054     struct has_stream_functions<edm::limited::EDFilterBase> {
0055       static bool constexpr value = true;
0056     };
0057 
0058     template <>
0059     struct has_stream_functions<edm::limited::EDAnalyzerBase> {
0060       static bool constexpr value = true;
0061     };
0062 
0063     template <>
0064     struct has_stream_functions<edm::stream::EDProducerAdaptorBase> {
0065       static bool constexpr value = true;
0066     };
0067 
0068     template <>
0069     struct has_stream_functions<edm::stream::EDFilterAdaptorBase> {
0070       static bool constexpr value = true;
0071     };
0072 
0073     template <>
0074     struct has_stream_functions<edm::stream::EDAnalyzerAdaptorBase> {
0075       static bool constexpr value = true;
0076     };
0077 
0078     template <typename T>
0079     struct has_only_stream_transition_functions {
0080       static bool constexpr value = false;
0081     };
0082 
0083     template <>
0084     struct has_only_stream_transition_functions<edm::global::OutputModuleBase> {
0085       static bool constexpr value = true;
0086     };
0087 
0088     struct DoNothing {
0089       template <typename... T>
0090       inline void operator()(const T&...) {}
0091     };
0092 
0093     template <typename T>
0094     struct DoBeginStream {
0095       inline void operator()(WorkerT<T>* iWorker, StreamID id) { iWorker->callWorkerBeginStream(0, id); }
0096     };
0097 
0098     template <typename T>
0099     struct DoEndStream {
0100       inline void operator()(WorkerT<T>* iWorker, StreamID id) { iWorker->callWorkerEndStream(0, id); }
0101     };
0102 
0103     template <typename T, typename INFOTYPE>
0104     struct DoStreamBeginTrans {
0105       inline void operator()(WorkerT<T>* iWorker, StreamID id, INFOTYPE const& info, ModuleCallingContext const* mcc) {
0106         iWorker->callWorkerStreamBegin(0, id, info, mcc);
0107       }
0108     };
0109 
0110     template <typename T, typename INFOTYPE>
0111     struct DoStreamEndTrans {
0112       inline void operator()(WorkerT<T>* iWorker, StreamID id, INFOTYPE const& info, ModuleCallingContext const* mcc) {
0113         iWorker->callWorkerStreamEnd(0, id, info, mcc);
0114       }
0115     };
0116   }  // namespace workerimpl
0117 
0118   template <typename T>
0119   inline WorkerT<T>::WorkerT(std::shared_ptr<T> ed, ModuleDescription const& md, ExceptionToActionTable const* actions)
0120       : Worker(md, actions), module_(ed) {
0121     assert(module_ != nullptr);
0122   }
0123 
0124   template <typename T>
0125   WorkerT<T>::~WorkerT() {}
0126 
0127   template <typename T>
0128   bool WorkerT<T>::wantsProcessBlocks() const noexcept {
0129     return module_->wantsProcessBlocks();
0130   }
0131 
0132   template <typename T>
0133   bool WorkerT<T>::wantsInputProcessBlocks() const noexcept {
0134     return module_->wantsInputProcessBlocks();
0135   }
0136 
0137   template <typename T>
0138   bool WorkerT<T>::wantsGlobalRuns() const noexcept {
0139     return module_->wantsGlobalRuns();
0140   }
0141 
0142   template <typename T>
0143   bool WorkerT<T>::wantsGlobalLuminosityBlocks() const noexcept {
0144     return module_->wantsGlobalLuminosityBlocks();
0145   }
0146 
0147   template <typename T>
0148   bool WorkerT<T>::wantsStreamRuns() const noexcept {
0149     return module_->wantsStreamRuns();
0150   }
0151 
0152   template <typename T>
0153   bool WorkerT<T>::wantsStreamLuminosityBlocks() const noexcept {
0154     return module_->wantsStreamLuminosityBlocks();
0155   }
0156 
0157   template <typename T>
0158   SerialTaskQueue* WorkerT<T>::globalRunsQueue() {
0159     return nullptr;
0160   }
0161   template <typename T>
0162   SerialTaskQueue* WorkerT<T>::globalLuminosityBlocksQueue() {
0163     return nullptr;
0164   }
0165 
0166   //one
0167   template <>
0168   SerialTaskQueue* WorkerT<one::EDProducerBase>::globalRunsQueue() {
0169     return module_->globalRunsQueue();
0170   }
0171   template <>
0172   SerialTaskQueue* WorkerT<one::EDProducerBase>::globalLuminosityBlocksQueue() {
0173     return module_->globalLuminosityBlocksQueue();
0174   }
0175   template <>
0176   SerialTaskQueue* WorkerT<one::EDFilterBase>::globalRunsQueue() {
0177     return module_->globalRunsQueue();
0178   }
0179   template <>
0180   SerialTaskQueue* WorkerT<one::EDFilterBase>::globalLuminosityBlocksQueue() {
0181     return module_->globalLuminosityBlocksQueue();
0182   }
0183   template <>
0184   SerialTaskQueue* WorkerT<one::EDAnalyzerBase>::globalRunsQueue() {
0185     return module_->globalRunsQueue();
0186   }
0187   template <>
0188   SerialTaskQueue* WorkerT<one::EDAnalyzerBase>::globalLuminosityBlocksQueue() {
0189     return module_->globalLuminosityBlocksQueue();
0190   }
0191   template <>
0192   SerialTaskQueue* WorkerT<one::OutputModuleBase>::globalRunsQueue() {
0193     return module_->globalRunsQueue();
0194   }
0195   template <>
0196   SerialTaskQueue* WorkerT<one::OutputModuleBase>::globalLuminosityBlocksQueue() {
0197     return module_->globalLuminosityBlocksQueue();
0198   }
0199 
0200   template <typename T>
0201   inline bool WorkerT<T>::implDo(EventTransitionInfo const& info, ModuleCallingContext const* mcc) {
0202     EventPrincipal const& ep = info.principal();
0203     std::shared_ptr<Worker> sentry(this, [&ep](Worker* obj) { obj->postDoEvent(ep); });
0204     return module_->doEvent(info, activityRegistry(), mcc);
0205   }
0206 
0207   template <typename T>
0208   inline void WorkerT<T>::implDoAcquire(EventTransitionInfo const&, ModuleCallingContext const*, WaitingTaskHolder&&) {}
0209 
0210   template <>
0211   inline void WorkerT<global::EDProducerBase>::implDoAcquire(EventTransitionInfo const& info,
0212                                                              ModuleCallingContext const* mcc,
0213                                                              WaitingTaskHolder&& holder) {
0214     module_->doAcquire(info, activityRegistry(), mcc, std::move(holder));
0215   }
0216 
0217   template <>
0218   inline void WorkerT<global::EDFilterBase>::implDoAcquire(EventTransitionInfo const& info,
0219                                                            ModuleCallingContext const* mcc,
0220                                                            WaitingTaskHolder&& holder) {
0221     module_->doAcquire(info, activityRegistry(), mcc, std::move(holder));
0222   }
0223 
0224   template <>
0225   inline void WorkerT<global::OutputModuleBase>::implDoAcquire(EventTransitionInfo const& info,
0226                                                                ModuleCallingContext const* mcc,
0227                                                                WaitingTaskHolder&& holder) {
0228     module_->doAcquire(info, activityRegistry(), mcc, std::move(holder));
0229   }
0230 
0231   template <>
0232   inline void WorkerT<stream::EDProducerAdaptorBase>::implDoAcquire(EventTransitionInfo const& info,
0233                                                                     ModuleCallingContext const* mcc,
0234                                                                     WaitingTaskHolder&& holder) {
0235     module_->doAcquire(info, activityRegistry(), mcc, std::move(holder));
0236   }
0237 
0238   template <>
0239   inline void WorkerT<stream::EDFilterAdaptorBase>::implDoAcquire(EventTransitionInfo const& info,
0240                                                                   ModuleCallingContext const* mcc,
0241                                                                   WaitingTaskHolder&& holder) {
0242     module_->doAcquire(info, activityRegistry(), mcc, std::move(holder));
0243   }
0244 
0245   template <typename T>
0246   inline void WorkerT<T>::implDoTransformAsync(WaitingTaskHolder iTask,
0247                                                size_t iTransformIndex,
0248                                                EventPrincipal const& iEvent,
0249                                                ParentContext const& iParent,
0250                                                ServiceWeakToken const& weakToken) noexcept {
0251     CMS_SA_ALLOW try {
0252       ServiceRegistry::Operate guard(weakToken.lock());
0253 
0254       ModuleCallingContext mcc(
0255           &module_->moduleDescription(), iTransformIndex + 1, ModuleCallingContext::State::kRunning, iParent, nullptr);
0256       module_->doTransformAsync(iTask, iTransformIndex, iEvent, activityRegistry(), mcc, weakToken);
0257     } catch (...) {
0258       iTask.doneWaiting(std::current_exception());
0259       return;
0260     }
0261     iTask.doneWaiting(std::exception_ptr());
0262   }
0263 
0264   template <>
0265   inline void WorkerT<global::EDAnalyzerBase>::implDoTransformAsync(WaitingTaskHolder task,
0266                                                                     size_t iTransformIndex,
0267                                                                     EventPrincipal const& iEvent,
0268                                                                     ParentContext const& iParent,
0269                                                                     ServiceWeakToken const& weakToken) noexcept {}
0270   template <>
0271   inline void WorkerT<global::OutputModuleBase>::implDoTransformAsync(WaitingTaskHolder task,
0272                                                                       size_t iTransformIndex,
0273                                                                       EventPrincipal const& iEvent,
0274                                                                       ParentContext const& iParent,
0275                                                                       ServiceWeakToken const& weakToken) noexcept {}
0276   template <>
0277   inline void WorkerT<limited::EDAnalyzerBase>::implDoTransformAsync(WaitingTaskHolder task,
0278                                                                      size_t iTransformIndex,
0279                                                                      EventPrincipal const& iEvent,
0280                                                                      ParentContext const& iParent,
0281                                                                      ServiceWeakToken const& weakToken) noexcept {}
0282   template <>
0283   inline void WorkerT<limited::OutputModuleBase>::implDoTransformAsync(WaitingTaskHolder task,
0284                                                                        size_t iTransformIndex,
0285                                                                        EventPrincipal const& iEvent,
0286                                                                        ParentContext const& iParent,
0287                                                                        ServiceWeakToken const& weakToken) noexcept {}
0288   template <>
0289   inline void WorkerT<one::EDAnalyzerBase>::implDoTransformAsync(WaitingTaskHolder task,
0290                                                                  size_t iTransformIndex,
0291                                                                  EventPrincipal const& iEvent,
0292                                                                  ParentContext const& iParent,
0293                                                                  ServiceWeakToken const& weakToken) noexcept {}
0294   template <>
0295   inline void WorkerT<one::OutputModuleBase>::implDoTransformAsync(WaitingTaskHolder task,
0296                                                                    size_t iTransformIndex,
0297                                                                    EventPrincipal const& iEvent,
0298                                                                    ParentContext const& iParent,
0299                                                                    ServiceWeakToken const& weakToken) noexcept {}
0300   template <>
0301   inline void WorkerT<stream::EDAnalyzerAdaptorBase>::implDoTransformAsync(WaitingTaskHolder task,
0302                                                                            size_t iTransformIndex,
0303                                                                            EventPrincipal const& iEvent,
0304                                                                            ParentContext const& iParent,
0305                                                                            ServiceWeakToken const& weakToken) noexcept {
0306   }
0307 
0308   template <typename T>
0309   inline size_t WorkerT<T>::transformIndex(edm::ProductDescription const&) const noexcept {
0310     return -1;
0311   }
0312   template <>
0313   inline size_t WorkerT<global::EDFilterBase>::transformIndex(edm::ProductDescription const& iBranch) const noexcept {
0314     return module_->transformIndex_(iBranch);
0315   }
0316   template <>
0317   inline size_t WorkerT<global::EDProducerBase>::transformIndex(edm::ProductDescription const& iBranch) const noexcept {
0318     return module_->transformIndex_(iBranch);
0319   }
0320   template <>
0321   inline size_t WorkerT<stream::EDProducerAdaptorBase>::transformIndex(
0322       edm::ProductDescription const& iBranch) const noexcept {
0323     return module_->transformIndex_(iBranch);
0324   }
0325   template <>
0326   inline size_t WorkerT<limited::EDFilterBase>::transformIndex(edm::ProductDescription const& iBranch) const noexcept {
0327     return module_->transformIndex_(iBranch);
0328   }
0329   template <>
0330   inline size_t WorkerT<limited::EDProducerBase>::transformIndex(edm::ProductDescription const& iBranch) const noexcept {
0331     return module_->transformIndex_(iBranch);
0332   }
0333   template <>
0334   inline size_t WorkerT<one::EDFilterBase>::transformIndex(edm::ProductDescription const& iBranch) const noexcept {
0335     return module_->transformIndex_(iBranch);
0336   }
0337   template <>
0338   inline size_t WorkerT<one::EDProducerBase>::transformIndex(edm::ProductDescription const& iBranch) const noexcept {
0339     return module_->transformIndex_(iBranch);
0340   }
0341 
0342   template <typename T>
0343   inline ProductResolverIndex WorkerT<T>::itemToGetForTransform(size_t iTransformIndex) const noexcept {
0344     return -1;
0345   }
0346   template <>
0347   inline ProductResolverIndex WorkerT<global::EDFilterBase>::itemToGetForTransform(
0348       size_t iTransformIndex) const noexcept {
0349     return module_->transformPrefetch_(iTransformIndex);
0350   }
0351   template <>
0352   inline ProductResolverIndex WorkerT<global::EDProducerBase>::itemToGetForTransform(
0353       size_t iTransformIndex) const noexcept {
0354     return module_->transformPrefetch_(iTransformIndex);
0355   }
0356   template <>
0357   inline ProductResolverIndex WorkerT<stream::EDProducerAdaptorBase>::itemToGetForTransform(
0358       size_t iTransformIndex) const noexcept {
0359     return module_->transformPrefetch_(iTransformIndex);
0360   }
0361   template <>
0362   inline ProductResolverIndex WorkerT<limited::EDFilterBase>::itemToGetForTransform(
0363       size_t iTransformIndex) const noexcept {
0364     return module_->transformPrefetch_(iTransformIndex);
0365   }
0366   template <>
0367   inline ProductResolverIndex WorkerT<limited::EDProducerBase>::itemToGetForTransform(
0368       size_t iTransformIndex) const noexcept {
0369     return module_->transformPrefetch_(iTransformIndex);
0370   }
0371   template <>
0372   inline ProductResolverIndex WorkerT<one::EDFilterBase>::itemToGetForTransform(size_t iTransformIndex) const noexcept {
0373     return module_->transformPrefetch_(iTransformIndex);
0374   }
0375   template <>
0376   inline ProductResolverIndex WorkerT<one::EDProducerBase>::itemToGetForTransform(
0377       size_t iTransformIndex) const noexcept {
0378     return module_->transformPrefetch_(iTransformIndex);
0379   }
0380 
0381   template <typename T>
0382   inline bool WorkerT<T>::implNeedToRunSelection() const noexcept {
0383     return false;
0384   }
0385 
0386   template <typename T>
0387   inline bool WorkerT<T>::implDoPrePrefetchSelection(StreamID id,
0388                                                      EventPrincipal const& ep,
0389                                                      ModuleCallingContext const* mcc) {
0390     return true;
0391   }
0392   template <typename T>
0393   inline void WorkerT<T>::itemsToGetForSelection(std::vector<ProductResolverIndexAndSkipBit>&) const {}
0394 
0395   template <>
0396   inline bool WorkerT<edm::one::OutputModuleBase>::implNeedToRunSelection() const noexcept {
0397     return true;
0398   }
0399 
0400   template <>
0401   inline bool WorkerT<edm::one::OutputModuleBase>::implDoPrePrefetchSelection(StreamID id,
0402                                                                               EventPrincipal const& ep,
0403                                                                               ModuleCallingContext const* mcc) {
0404     return module_->prePrefetchSelection(id, ep, mcc);
0405   }
0406   template <>
0407   inline void WorkerT<edm::one::OutputModuleBase>::itemsToGetForSelection(
0408       std::vector<ProductResolverIndexAndSkipBit>& iItems) const {
0409     iItems = module_->productsUsedBySelection();
0410   }
0411 
0412   template <>
0413   inline bool WorkerT<edm::global::OutputModuleBase>::implNeedToRunSelection() const noexcept {
0414     return true;
0415   }
0416   template <>
0417   inline bool WorkerT<edm::global::OutputModuleBase>::implDoPrePrefetchSelection(StreamID id,
0418                                                                                  EventPrincipal const& ep,
0419                                                                                  ModuleCallingContext const* mcc) {
0420     return module_->prePrefetchSelection(id, ep, mcc);
0421   }
0422   template <>
0423   inline void WorkerT<edm::global::OutputModuleBase>::itemsToGetForSelection(
0424       std::vector<ProductResolverIndexAndSkipBit>& iItems) const {
0425     iItems = module_->productsUsedBySelection();
0426   }
0427 
0428   template <>
0429   inline bool WorkerT<edm::limited::OutputModuleBase>::implNeedToRunSelection() const noexcept {
0430     return true;
0431   }
0432   template <>
0433   inline bool WorkerT<edm::limited::OutputModuleBase>::implDoPrePrefetchSelection(StreamID id,
0434                                                                                   EventPrincipal const& ep,
0435                                                                                   ModuleCallingContext const* mcc) {
0436     return module_->prePrefetchSelection(id, ep, mcc);
0437   }
0438   template <>
0439   inline void WorkerT<edm::limited::OutputModuleBase>::itemsToGetForSelection(
0440       std::vector<ProductResolverIndexAndSkipBit>& iItems) const {
0441     iItems = module_->productsUsedBySelection();
0442   }
0443 
0444   template <typename T>
0445   bool WorkerT<T>::implDoBeginProcessBlock(ProcessBlockPrincipal const& pbp, ModuleCallingContext const* mcc) {
0446     module_->doBeginProcessBlock(pbp, mcc);
0447     return true;
0448   }
0449 
0450   template <typename T>
0451   bool WorkerT<T>::implDoAccessInputProcessBlock(ProcessBlockPrincipal const& pbp, ModuleCallingContext const* mcc) {
0452     module_->doAccessInputProcessBlock(pbp, mcc);
0453     return true;
0454   }
0455 
0456   template <typename T>
0457   bool WorkerT<T>::implDoEndProcessBlock(ProcessBlockPrincipal const& pbp, ModuleCallingContext const* mcc) {
0458     module_->doEndProcessBlock(pbp, mcc);
0459     return true;
0460   }
0461 
0462   template <typename T>
0463   inline bool WorkerT<T>::implDoBegin(RunTransitionInfo const& info, ModuleCallingContext const* mcc) {
0464     module_->doBeginRun(info, mcc);
0465     return true;
0466   }
0467 
0468   template <typename T>
0469   template <typename D>
0470   void WorkerT<T>::callWorkerStreamBegin(D,
0471                                          StreamID id,
0472                                          RunTransitionInfo const& info,
0473                                          ModuleCallingContext const* mcc) {
0474     module_->doStreamBeginRun(id, info, mcc);
0475   }
0476 
0477   template <typename T>
0478   template <typename D>
0479   void WorkerT<T>::callWorkerStreamEnd(D, StreamID id, RunTransitionInfo const& info, ModuleCallingContext const* mcc) {
0480     module_->doStreamEndRun(id, info, mcc);
0481   }
0482 
0483   template <typename T>
0484   inline bool WorkerT<T>::implDoStreamBegin(StreamID id,
0485                                             RunTransitionInfo const& info,
0486                                             ModuleCallingContext const* mcc) {
0487     std::conditional_t<workerimpl::has_stream_functions<T>::value,
0488                        workerimpl::DoStreamBeginTrans<T, RunTransitionInfo const>,
0489                        workerimpl::DoNothing>
0490         might_call;
0491     might_call(this, id, info, mcc);
0492     return true;
0493   }
0494 
0495   template <typename T>
0496   inline bool WorkerT<T>::implDoStreamEnd(StreamID id, RunTransitionInfo const& info, ModuleCallingContext const* mcc) {
0497     std::conditional_t<workerimpl::has_stream_functions<T>::value,
0498                        workerimpl::DoStreamEndTrans<T, RunTransitionInfo const>,
0499                        workerimpl::DoNothing>
0500         might_call;
0501     might_call(this, id, info, mcc);
0502     return true;
0503   }
0504 
0505   template <typename T>
0506   inline bool WorkerT<T>::implDoEnd(RunTransitionInfo const& info, ModuleCallingContext const* mcc) {
0507     module_->doEndRun(info, mcc);
0508     return true;
0509   }
0510 
0511   template <typename T>
0512   inline bool WorkerT<T>::implDoBegin(LumiTransitionInfo const& info, ModuleCallingContext const* mcc) {
0513     module_->doBeginLuminosityBlock(info, mcc);
0514     return true;
0515   }
0516 
0517   template <typename T>
0518   template <typename D>
0519   void WorkerT<T>::callWorkerStreamBegin(D,
0520                                          StreamID id,
0521                                          LumiTransitionInfo const& info,
0522                                          ModuleCallingContext const* mcc) {
0523     module_->doStreamBeginLuminosityBlock(id, info, mcc);
0524   }
0525 
0526   template <typename T>
0527   template <typename D>
0528   void WorkerT<T>::callWorkerStreamEnd(D, StreamID id, LumiTransitionInfo const& info, ModuleCallingContext const* mcc) {
0529     module_->doStreamEndLuminosityBlock(id, info, mcc);
0530   }
0531 
0532   template <typename T>
0533   inline bool WorkerT<T>::implDoStreamBegin(StreamID id,
0534                                             LumiTransitionInfo const& info,
0535                                             ModuleCallingContext const* mcc) {
0536     std::conditional_t<workerimpl::has_stream_functions<T>::value,
0537                        workerimpl::DoStreamBeginTrans<T, LumiTransitionInfo>,
0538                        workerimpl::DoNothing>
0539         might_call;
0540     might_call(this, id, info, mcc);
0541     return true;
0542   }
0543 
0544   template <typename T>
0545   inline bool WorkerT<T>::implDoStreamEnd(StreamID id,
0546                                           LumiTransitionInfo const& info,
0547                                           ModuleCallingContext const* mcc) {
0548     std::conditional_t<workerimpl::has_stream_functions<T>::value,
0549                        workerimpl::DoStreamEndTrans<T, LumiTransitionInfo>,
0550                        workerimpl::DoNothing>
0551         might_call;
0552     might_call(this, id, info, mcc);
0553 
0554     return true;
0555   }
0556 
0557   template <typename T>
0558   inline bool WorkerT<T>::implDoEnd(LumiTransitionInfo const& info, ModuleCallingContext const* mcc) {
0559     module_->doEndLuminosityBlock(info, mcc);
0560     return true;
0561   }
0562 
0563   template <typename T>
0564   inline std::string WorkerT<T>::workerType() const {
0565     return module_->workerType();
0566   }
0567 
0568   template <typename T>
0569   inline void WorkerT<T>::implBeginJob() {
0570     module_->doBeginJob();
0571   }
0572 
0573   template <typename T>
0574   inline void WorkerT<T>::implEndJob() {
0575     module_->doEndJob();
0576   }
0577 
0578   template <typename T>
0579   template <typename D>
0580   void WorkerT<T>::callWorkerBeginStream(D, StreamID id) {
0581     module_->doBeginStream(id);
0582   }
0583 
0584   template <typename T>
0585   inline void WorkerT<T>::implBeginStream(StreamID id) {
0586     std::conditional_t<workerimpl::has_stream_functions<T>::value or
0587                            workerimpl::has_only_stream_transition_functions<T>::value,
0588                        workerimpl::DoBeginStream<T>,
0589                        workerimpl::DoNothing>
0590         might_call;
0591     might_call(this, id);
0592   }
0593 
0594   template <typename T>
0595   template <typename D>
0596   void WorkerT<T>::callWorkerEndStream(D, StreamID id) {
0597     module_->doEndStream(id);
0598   }
0599 
0600   template <typename T>
0601   inline void WorkerT<T>::implEndStream(StreamID id) {
0602     std::conditional_t<workerimpl::has_stream_functions<T>::value or
0603                            workerimpl::has_only_stream_transition_functions<T>::value,
0604                        workerimpl::DoEndStream<T>,
0605                        workerimpl::DoNothing>
0606         might_call;
0607     might_call(this, id);
0608   }
0609 
0610   template <typename T>
0611   inline void WorkerT<T>::implRespondToOpenInputFile(FileBlock const& fb) {
0612     module_->doRespondToOpenInputFile(fb);
0613   }
0614 
0615   template <typename T>
0616   inline void WorkerT<T>::implRespondToCloseInputFile(FileBlock const& fb) {
0617     module_->doRespondToCloseInputFile(fb);
0618   }
0619 
0620   template <typename T>
0621   void WorkerT<T>::implRespondToCloseOutputFile() {
0622     module_->doRespondToCloseOutputFile();
0623   }
0624 
0625   template <typename T>
0626   inline Worker::TaskQueueAdaptor WorkerT<T>::serializeRunModule() {
0627     return Worker::TaskQueueAdaptor{};
0628   }
0629   template <>
0630   Worker::TaskQueueAdaptor WorkerT<one::EDAnalyzerBase>::serializeRunModule() {
0631     return &(module_->sharedResourcesAcquirer().serialQueueChain());
0632   }
0633   template <>
0634   Worker::TaskQueueAdaptor WorkerT<one::EDFilterBase>::serializeRunModule() {
0635     return &(module_->sharedResourcesAcquirer().serialQueueChain());
0636   }
0637   template <>
0638   Worker::TaskQueueAdaptor WorkerT<one::EDProducerBase>::serializeRunModule() {
0639     return &(module_->sharedResourcesAcquirer().serialQueueChain());
0640   }
0641   template <>
0642   Worker::TaskQueueAdaptor WorkerT<one::OutputModuleBase>::serializeRunModule() {
0643     return &(module_->sharedResourcesAcquirer().serialQueueChain());
0644   }
0645   template <>
0646   Worker::TaskQueueAdaptor WorkerT<limited::EDAnalyzerBase>::serializeRunModule() {
0647     return &(module_->queue());
0648   }
0649   template <>
0650   Worker::TaskQueueAdaptor WorkerT<limited::EDFilterBase>::serializeRunModule() {
0651     return &(module_->queue());
0652   }
0653   template <>
0654   Worker::TaskQueueAdaptor WorkerT<limited::EDProducerBase>::serializeRunModule() {
0655     return &(module_->queue());
0656   }
0657   template <>
0658   Worker::TaskQueueAdaptor WorkerT<limited::OutputModuleBase>::serializeRunModule() {
0659     return &(module_->queue());
0660   }
0661 
0662   template <>
0663   Worker::Types WorkerT<edm::one::EDProducerBase>::moduleType() const {
0664     return Worker::kProducer;
0665   }
0666   template <>
0667   Worker::Types WorkerT<edm::one::EDFilterBase>::moduleType() const {
0668     return Worker::kFilter;
0669   }
0670   template <>
0671   Worker::Types WorkerT<edm::one::EDAnalyzerBase>::moduleType() const {
0672     return Worker::kAnalyzer;
0673   }
0674   template <>
0675   Worker::Types WorkerT<edm::one::OutputModuleBase>::moduleType() const {
0676     return Worker::kOutputModule;
0677   }
0678 
0679   template <>
0680   Worker::Types WorkerT<edm::global::EDProducerBase>::moduleType() const {
0681     return Worker::kProducer;
0682   }
0683   template <>
0684   Worker::Types WorkerT<edm::global::EDFilterBase>::moduleType() const {
0685     return Worker::kFilter;
0686   }
0687   template <>
0688   Worker::Types WorkerT<edm::global::EDAnalyzerBase>::moduleType() const {
0689     return Worker::kAnalyzer;
0690   }
0691   template <>
0692   Worker::Types WorkerT<edm::global::OutputModuleBase>::moduleType() const {
0693     return Worker::kOutputModule;
0694   }
0695 
0696   template <>
0697   Worker::Types WorkerT<edm::limited::EDProducerBase>::moduleType() const {
0698     return Worker::kProducer;
0699   }
0700   template <>
0701   Worker::Types WorkerT<edm::limited::EDFilterBase>::moduleType() const {
0702     return Worker::kFilter;
0703   }
0704   template <>
0705   Worker::Types WorkerT<edm::limited::EDAnalyzerBase>::moduleType() const {
0706     return Worker::kAnalyzer;
0707   }
0708   template <>
0709   Worker::Types WorkerT<edm::limited::OutputModuleBase>::moduleType() const {
0710     return Worker::kOutputModule;
0711   }
0712 
0713   template <>
0714   Worker::Types WorkerT<edm::stream::EDProducerAdaptorBase>::moduleType() const {
0715     return Worker::kProducer;
0716   }
0717   template <>
0718   Worker::Types WorkerT<edm::stream::EDFilterAdaptorBase>::moduleType() const {
0719     return Worker::kFilter;
0720   }
0721   template <>
0722   Worker::Types WorkerT<edm::stream::EDAnalyzerAdaptorBase>::moduleType() const {
0723     return Worker::kAnalyzer;
0724   }
0725 
0726   template <>
0727   Worker::ConcurrencyTypes WorkerT<edm::one::EDProducerBase>::moduleConcurrencyType() const {
0728     return Worker::kOne;
0729   }
0730   template <>
0731   Worker::ConcurrencyTypes WorkerT<edm::one::EDFilterBase>::moduleConcurrencyType() const {
0732     return Worker::kOne;
0733   }
0734   template <>
0735   Worker::ConcurrencyTypes WorkerT<edm::one::EDAnalyzerBase>::moduleConcurrencyType() const {
0736     return Worker::kOne;
0737   }
0738   template <>
0739   Worker::ConcurrencyTypes WorkerT<edm::one::OutputModuleBase>::moduleConcurrencyType() const {
0740     return Worker::kOne;
0741   }
0742 
0743   template <>
0744   Worker::ConcurrencyTypes WorkerT<edm::global::EDProducerBase>::moduleConcurrencyType() const {
0745     return Worker::kGlobal;
0746   }
0747   template <>
0748   Worker::ConcurrencyTypes WorkerT<edm::global::EDFilterBase>::moduleConcurrencyType() const {
0749     return Worker::kGlobal;
0750   }
0751   template <>
0752   Worker::ConcurrencyTypes WorkerT<edm::global::EDAnalyzerBase>::moduleConcurrencyType() const {
0753     return Worker::kGlobal;
0754   }
0755   template <>
0756   Worker::ConcurrencyTypes WorkerT<edm::global::OutputModuleBase>::moduleConcurrencyType() const {
0757     return Worker::kGlobal;
0758   }
0759 
0760   template <>
0761   Worker::ConcurrencyTypes WorkerT<edm::limited::EDProducerBase>::moduleConcurrencyType() const {
0762     return Worker::kLimited;
0763   }
0764   template <>
0765   Worker::ConcurrencyTypes WorkerT<edm::limited::EDFilterBase>::moduleConcurrencyType() const {
0766     return Worker::kLimited;
0767   }
0768   template <>
0769   Worker::ConcurrencyTypes WorkerT<edm::limited::EDAnalyzerBase>::moduleConcurrencyType() const {
0770     return Worker::kLimited;
0771   }
0772   template <>
0773   Worker::ConcurrencyTypes WorkerT<edm::limited::OutputModuleBase>::moduleConcurrencyType() const {
0774     return Worker::kLimited;
0775   }
0776 
0777   template <>
0778   Worker::ConcurrencyTypes WorkerT<edm::stream::EDProducerAdaptorBase>::moduleConcurrencyType() const {
0779     return Worker::kStream;
0780   }
0781   template <>
0782   Worker::ConcurrencyTypes WorkerT<edm::stream::EDFilterAdaptorBase>::moduleConcurrencyType() const {
0783     return Worker::kStream;
0784   }
0785   template <>
0786   Worker::ConcurrencyTypes WorkerT<edm::stream::EDAnalyzerAdaptorBase>::moduleConcurrencyType() const {
0787     return Worker::kStream;
0788   }
0789 
0790   template <typename T>
0791   std::vector<ModuleConsumesInfo> WorkerT<T>::moduleConsumesInfos() const {
0792     return module_->moduleConsumesInfos();
0793   }
0794 
0795   //Explicitly instantiate our needed templates to avoid having the compiler
0796   // instantiate them in all of our libraries
0797   template class WorkerT<one::EDProducerBase>;
0798   template class WorkerT<one::EDFilterBase>;
0799   template class WorkerT<one::EDAnalyzerBase>;
0800   template class WorkerT<one::OutputModuleBase>;
0801   template class WorkerT<global::EDProducerBase>;
0802   template class WorkerT<global::EDFilterBase>;
0803   template class WorkerT<global::EDAnalyzerBase>;
0804   template class WorkerT<global::OutputModuleBase>;
0805   template class WorkerT<stream::EDProducerAdaptorBase>;
0806   template class WorkerT<stream::EDFilterAdaptorBase>;
0807   template class WorkerT<stream::EDAnalyzerAdaptorBase>;
0808   template class WorkerT<limited::EDProducerBase>;
0809   template class WorkerT<limited::EDFilterBase>;
0810   template class WorkerT<limited::EDAnalyzerBase>;
0811   template class WorkerT<limited::OutputModuleBase>;
0812 }  // namespace edm