Framework/interface/ESProductResolverFactoryProducer.h

0001 // -*- C++ -*-
0002 #ifndef Framework_ESProductResolverFactoryProducer_h
0003 #define Framework_ESProductResolverFactoryProducer_h
0004 //
0005 // Package:     Framework
0006 // Class  :     ESProductResolverFactoryProducer
0007 //
0008 /**\class edm::ESProductResolverFactoryProducer
0009
0010  Description: An EventSetup algorithmic Provider that manages Factories of Resolvers
0011
0012  Usage:
0013     This class is used when the algorithms in the EventSetup that are to be run on demand are encapsulated
0014   in edm::eventsetup::ProductResolvers's.  This 'design pattern' is more flexible than having the algorithm embedded
0015   directly in the Provider (see ESProducer for such an implemenation).
0016
0017     Users inherit from this class and then call the 'registerFactory' method in their class' constructor
0018   in order to get their Resolvers registered.  For most users, the already available templated Factory classes
0019   should suffice and therefore they should not need to create their own Factories.
0020
0021 Example: register one Factory that creates a resolver that takes no arguments
0022 \code
0023    class FooResolver : public edm::eventsetup::ESProductResolver { ... };
0024    class FooProd : public edm::ESProductResolverFactoryProducer { ... };
0025
0026    FooProd::FooProd(const edm::ParameterSet&) {
0027       typedef edm::eventsetup::ESProductResolverFactoryTemplate<FooResolver> > TYPE;
0028       registerFactory(std::make_unique<TYPE>();
0029    };
0030
0031 \endcode
0032
0033 Example: register one Factory that creates a resolver that takes one argument
0034 \code
0035 class BarResolver : public edm::eventsetup::ESProductResolver { ...
0036    BarResolver(const edm::ParameterSet&) ;
0037    ... };
0038 class BarProd : public edm::ESProductResolverFactoryProducer { ... };
0039
0040 BarProd::BarProd(const edm::ParameterSet& iPS) {
0041    typedef edm::eventsetup::ESProductResolverArgumentFactoryTemplate<BarResolver, edm::ParmeterSet> TYPE;
0042    registerFactory(std::make_unique<TYPE>(iPS);
0043 };
0044
0045 \endcode
0046
0047 */
0048 //
0049 // Author:      Chris Jones
0050 // Created:     Thu Apr  7 17:14:58 CDT 2005
0051 //
0052
0053 // system include files
0054 #include <map>
0055 #include <memory>
0056 #include <string>
0057
0058 // user include files
0059
0060 // forward declarations
0061 #include "FWCore/Framework/interface/ESProductResolverProvider.h"
0062 #include "FWCore/Utilities/interface/propagate_const.h"
0063
0064 namespace edm {
0065   namespace eventsetup {
0066     class ESProductResolverFactoryBase;
0067
0068     struct FactoryInfo {
0069       FactoryInfo() : key_(), factory_() {}
0070       FactoryInfo(const DataKey& iKey, std::shared_ptr<ESProductResolverFactoryBase> iFactory)
0071           : key_(iKey), factory_(iFactory) {}
0072       DataKey key_;
0073       edm::propagate_const<std::shared_ptr<ESProductResolverFactoryBase>> factory_;
0074     };
0075   }  // namespace eventsetup
0076
0077   class ESProductResolverFactoryProducer : public eventsetup::ESProductResolverProvider {
0078   public:
0079     ESProductResolverFactoryProducer();
0080
0081     ESProductResolverFactoryProducer(const ESProductResolverFactoryProducer&) = delete;
0082     const ESProductResolverFactoryProducer& operator=(const ESProductResolverFactoryProducer&) = delete;
0083
0084     ~ESProductResolverFactoryProducer() noexcept(false) override;
0085
0086     std::vector<eventsetup::ESModuleProducesInfo> producesInfo() const override;
0087
0088   protected:
0089     using EventSetupRecordKey = eventsetup::EventSetupRecordKey;
0090
0091     KeyedResolversVector registerResolvers(const EventSetupRecordKey&, unsigned int iovIndex) override;
0092
0093     /** \param iFactory unique_ptr holding a new instance of a Factory
0094          \param iLabel extra string label used to get data (optional)
0095          Producer takes ownership of the Factory and uses it create the appropriate
0096          Resolver which is then registered with the EventSetup.  If used, this method should
0097          be called in inheriting class' constructor.
0098       */
0099     template <class TFactory>
0100     void registerFactory(std::unique_ptr<TFactory> iFactory, const std::string& iLabel = std::string()) {
0101       std::unique_ptr<eventsetup::ESProductResolverFactoryBase> temp(iFactory.release());
0102       registerFactoryWithKey(EventSetupRecordKey::makeKey<typename TFactory::RecordType>(), std::move(temp), iLabel);
0103     }
0104
0105     virtual void registerFactoryWithKey(const EventSetupRecordKey& iRecord,
0106                                         std::unique_ptr<eventsetup::ESProductResolverFactoryBase> iFactory,
0107                                         const std::string& iLabel = std::string());
0108
0109   private:
0110     // ---------- member data --------------------------------
0111     std::multimap<EventSetupRecordKey, eventsetup::FactoryInfo> record2Factories_;
0112   };
0113
0114 }  // namespace edm
0115
0116 #endif