#include <ServicesManager.h>

Classes
struct	MakerHolder

Public Types
typedef std::map< TypeIDBase, MakerHolder >	Type2Maker

typedef std::map< TypeIDBase, std::shared_ptr< ServiceWrapperBase > >	Type2Service

Public Member Functions
void	connect (ActivityRegistry &iOther)
	causes our ActivityRegistry's signals to be forwarded to iOther More...

void	connectTo (ActivityRegistry &iOther)
	causes iOther's signals to be forward to us More...

void	copySlotsFrom (ActivityRegistry &)
	the copy the argument's slots to the our signals More...

void	copySlotsTo (ActivityRegistry &)
	copy our Service's slots to the argument's signals More...

template<typename T >
T &	get () const

template<typename T >
bool	isAvailable () const
	returns true of the particular service is accessible More...

template<typename T >
bool	put (std::shared_ptr< ServiceWrapper< T >> iPtr)
	returns false if put fails because a service of this type already exists More...

	ServicesManager (std::vector< ParameterSet > &iConfiguration)

	ServicesManager (ServiceToken iToken, ServiceLegacy iLegacy, std::vector< ParameterSet > &iConfiguration, bool associate=true)

	~ServicesManager ()

Private Member Functions
void	createServiceFor (MakerHolder const &)

void	createServices ()

void	fillListOfMakers (std::vector< ParameterSet > &)

ServicesManager const &	operator= (ServicesManager const &)=delete

	ServicesManager (ServicesManager const &)=delete

Private Attributes
std::vector< TypeIDBase >	actualCreationOrder_

edm::propagate_const< std::shared_ptr< ServicesManager > >	associatedManager_

ActivityRegistry	registry_

std::vector< TypeIDBase >	requestedCreationOrder_

edm::propagate_const< std::unique_ptr< Type2Maker > >	type2Maker_

Type2Service	type2Service_

Detailed Description

Definition at line 43 of file ServicesManager.h.

Member Typedef Documentation

typedef std::map<TypeIDBase, MakerHolder> edm::serviceregistry::ServicesManager::Type2Maker

Definition at line 55 of file ServicesManager.h.

typedef std::map<TypeIDBase, std::shared_ptr<ServiceWrapperBase> > edm::serviceregistry::ServicesManager::Type2Service

Definition at line 54 of file ServicesManager.h.

Constructor & Destructor Documentation

ServicesManager::ServicesManager ( std::vector< ParameterSet > & iConfiguration )

Definition at line 65 of file ServicesManager.cc.

References createServices(), and fillListOfMakers().

Referenced by put().

                                                                             : type2Maker_(new Type2Maker) {
       //First create the list of makers
       fillListOfMakers(iConfiguration);
 
       createServices();
     }

ServicesManager::ServicesManager	(	ServiceToken	iToken,
		ServiceLegacy	iLegacy,
		std::vector< ParameterSet > &	iConfiguration,
		bool	associate = `true`
	)

Takes the services described by iToken and places them into the manager. Conflicts over Services provided by both the iToken and iConfiguration are resolved based on the value of iLegacy

Definition at line 72 of file ServicesManager.cc.

References associatedManager_, edm::errors::Configuration, edm::ActivityRegistry::copySlotsFrom(), createServices(), Exception, fillListOfMakers(), reco::helper::VirtualJetProducerHelper::intersection(), edm::serviceregistry::kConfigurationOverrides, edm::serviceregistry::kOverlapIsError, edm::serviceregistry::kTokenOverrides, edm::ServiceToken::manager_, registry_, AlCaHLTBitMon_QueryRunRegistry::string, type2Maker_, type2Service_, and edm::typeDemangle().

         : associatedManager_(associate ? iToken.manager_ : std::shared_ptr<ServicesManager>()),
           type2Maker_(new Type2Maker) {
       fillListOfMakers(iConfiguration);
 
       //find overlaps between services in iToken and iConfiguration
       typedef std::set<TypeIDBase> TypeSet;
       TypeSet configTypes;
       for (Type2Maker::iterator itType = type2Maker_->begin(), itTypeEnd = type2Maker_->end(); itType != itTypeEnd;
            ++itType) {
         configTypes.insert(itType->first);
       }
 
       TypeSet tokenTypes;
       if (nullptr != iToken.manager_.get()) {
         for (Type2Service::iterator itType = iToken.manager_->type2Service_.begin(),
                                     itTypeEnd = iToken.manager_->type2Service_.end();
              itType != itTypeEnd;
              ++itType) {
           tokenTypes.insert(itType->first);
         }
 
         typedef std::set<TypeIDBase> IntersectionType;
         IntersectionType intersection;
         std::set_intersection(configTypes.begin(),
                               configTypes.end(),
                               tokenTypes.begin(),
                               tokenTypes.end(),
                               inserter(intersection, intersection.end()));
 
         switch (iLegacy) {
           case kOverlapIsError:
             if (!intersection.empty()) {
               throw Exception(errors::Configuration, "Service")
                   << "the Service "
                   << (*type2Maker_)
                          .find(*(intersection.begin()))
                          ->second.pset_->getParameter<std::string>("@service_type")
                   << " already has an instance of that type of Service";
             } else {
               //get all the services from Token
               type2Service_ = iToken.manager_->type2Service_;
             }
             break;
           case kTokenOverrides:
             //get all the services from Token
             type2Service_ = iToken.manager_->type2Service_;
 
             //remove from type2Maker the overlapping services so we never try to make them
             for (IntersectionType::iterator itType = intersection.begin(), itTypeEnd = intersection.end();
                  itType != itTypeEnd;
                  ++itType) {
               Type2Maker::iterator itFound = type2Maker_->find(*itType);
               //HLT needs it such that even if a service isn't created we store its PSet if needed
               if (itFound->second.maker_->saveConfiguration()) {
                 itFound->second.pset_->addUntrackedParameter("@save_config", true);
               }
               type2Maker_->erase(itFound);
             }
             break;
           case kConfigurationOverrides:
             //get all the services from the Configuration, except process wide services
             type2Service_ = iToken.manager_->type2Service_;
 
             //now remove the ones we do not want
             for (IntersectionType::iterator itType = intersection.begin(), itTypeEnd = intersection.end();
                  itType != itTypeEnd;
                  ++itType) {
               Type2Maker::iterator itFound = type2Maker_->find(*itType);
               if (itFound->second.maker_->processWideService()) {
                 // This is a process wide service, so the token overrides the configuration.
                 //HLT needs it such that even if a service isn't created we store its PSet if needed
                 if (itFound->second.maker_->saveConfiguration()) {
                   itFound->second.pset_->addUntrackedParameter("@save_config", true);
                 }
                 std::string type(typeDemangle(itType->name()));
                 LogInfo("Configuration") << "Warning: You have reconfigured service\n"
                                          << "'" << type << "' in a subprocess.\n"
                                          << "This service has already been configured.\n"
                                          << "This particular service may not be reconfigured in a subprocess.\n"
                                          << "The reconfiguration will be ignored.\n";
                 type2Maker_->erase(itFound);
               } else {
                 // This is not a process wide service, so the configuration overrides the token.
                 type2Service_.erase(type2Service_.find(*itType));
               }
             }
             break;
         }
         //make sure our signals are propagated to our 'inherited' Services
         if (associate)
           registry_.copySlotsFrom(associatedManager_->registry_);
       }
       createServices();
     }

ServicesManager::~ServicesManager ( )

Definition at line 175 of file ServicesManager.cc.

References actualCreationOrder_, and type2Service_.

                                       {
       // Force the Service destructors to execute in the reverse order of construction.
       // Note that services passed in by a token are not included in this loop and
       // do not get destroyed until the ServicesManager object that created them is destroyed
       // which occurs after the body of this destructor is executed (the correct order).
       // Services directly passed in by a put and not created in the constructor
       // may or not be detroyed in the desired order because this class does not control
       // their creation (as I'm writing this comment everything in a standard cmsRun
       // executable is destroyed in the desired order).
       for (std::vector<TypeIDBase>::const_reverse_iterator idIter = actualCreationOrder_.rbegin(),
                                                            idEnd = actualCreationOrder_.rend();
            idIter != idEnd;
            ++idIter) {
         Type2Service::iterator itService = type2Service_.find(*idIter);
 
         if (itService != type2Service_.end()) {
           // This will cause the Service's destruction if
           // there are no other shared pointers around
           itService->second.reset();
         }
       }
     }

edm::serviceregistry::ServicesManager::ServicesManager ( ServicesManager const & )

privatedelete

Member Function Documentation

void ServicesManager::connect ( ActivityRegistry & iOther )

causes our ActivityRegistry's signals to be forwarded to iOther

Definition at line 212 of file ServicesManager.cc.

References edm::ActivityRegistry::connect(), and registry_.

212 { registry_.connect(iOther); }

edm::serviceregistry::ServicesManager::registry_

ActivityRegistry registry_

Definition: ServicesManager.h:160

edm::ActivityRegistry::connect

void connect(ActivityRegistry &iOther)

forwards our signals to slots connected to iOther

Definition: ActivityRegistry.cc:265

void ServicesManager::connectTo ( ActivityRegistry & iOther )

causes iOther's signals to be forward to us

Definition at line 214 of file ServicesManager.cc.

References edm::ActivityRegistry::connect(), and registry_.

Referenced by put(), and edm::ServiceToken::ServiceToken().

214 { iOther.connect(registry_); }

edm::serviceregistry::ServicesManager::registry_

ActivityRegistry registry_

Definition: ServicesManager.h:160

void ServicesManager::copySlotsFrom ( ActivityRegistry & iOther )

the copy the argument's slots to the our signals

Definition at line 216 of file ServicesManager.cc.

References edm::ActivityRegistry::copySlotsFrom(), and registry_.

Referenced by put(), and edm::ServiceToken::ServiceToken().

216 { registry_.copySlotsFrom(iOther); }

edm::ActivityRegistry::copySlotsFrom

void copySlotsFrom(ActivityRegistry &iOther)

Definition: ActivityRegistry.cc:275

edm::serviceregistry::ServicesManager::registry_

ActivityRegistry registry_

Definition: ServicesManager.h:160

void ServicesManager::copySlotsTo ( ActivityRegistry & iOther )

copy our Service's slots to the argument's signals

Definition at line 218 of file ServicesManager.cc.

References edm::ActivityRegistry::copySlotsFrom(), and registry_.

Referenced by put(), and edm::ServiceToken::ServiceToken().

218 { iOther.copySlotsFrom(registry_); }

edm::serviceregistry::ServicesManager::registry_

ActivityRegistry registry_

Definition: ServicesManager.h:160

void ServicesManager::createServiceFor ( MakerHolder const & iMaker )

private

Definition at line 251 of file ServicesManager.cc.

References edm::serviceregistry::ServicesManager::MakerHolder::add(), cms::Exception::addContext(), beamerCreator::create(), trigObjTnPSource_cfi::filler, timingPdfMaker::get, edm::ParameterSet::getParameter(), edm::serviceregistry::ServicesManager::MakerHolder::pset_, AlCaHLTBitMon_QueryRunRegistry::string, and edm::convertException::wrap().

Referenced by createServices(), get(), isAvailable(), and put().

                                                                     {
       std::string serviceType = iMaker.pset_->getParameter<std::string>("@service_type");
       std::unique_ptr<ParameterSetDescriptionFillerBase> filler(
           ParameterSetDescriptionFillerPluginFactory::get()->create(serviceType));
       ConfigurationDescriptions descriptions(filler->baseType(), serviceType);
       filler->fill(descriptions);
 
       try {
         convertException::wrap([&]() { descriptions.validate(*(iMaker.pset_), serviceType); });
       } catch (cms::Exception& iException) {
         std::ostringstream ost;
         ost << "Validating configuration of service of type " << serviceType;
         iException.addContext(ost.str());
         throw;
       }
       try {
         convertException::wrap([&]() {
           // This creates the service
           iMaker.add(*this);
         });
       } catch (cms::Exception& iException) {
         std::ostringstream ost;
         ost << "Constructing service of type " << serviceType;
         iException.addContext(ost.str());
         throw;
       }
     }

void ServicesManager::createServices ( )

private

Definition at line 279 of file ServicesManager.cc.

References createServiceFor(), requestedCreationOrder_, unpackBuffers-CaloStage2::token, and type2Maker_.

Referenced by put(), and ServicesManager().

                                          {
       //create a shared_ptr of 'this' that will not delete us
       std::shared_ptr<ServicesManager> shareThis(this, NoOp());
 
       ServiceToken token(shareThis);
 
       //Now make our services to ones obtained via ServiceRegistry
       // when this goes out of scope, it will revert back to the previous Service set
       ServiceRegistry::Operate operate(token);
 
       //Now, make each Service.  If a service depends on a service that has yet to be
       // created, that other service will automatically be made
 
       for (std::vector<TypeIDBase>::const_iterator idIter = requestedCreationOrder_.begin(),
                                                    idEnd = requestedCreationOrder_.end();
            idIter != idEnd;
            ++idIter) {
         Type2Maker::iterator itMaker = type2Maker_->find(*idIter);
 
         // Check to make sure this maker is still there.  They are deleted
         // sometimes and that is OK.
         if (itMaker != type2Maker_->end()) {
           createServiceFor(itMaker->second);
         }
       }
       //No longer need the makers
       type2Maker_ = nullptr;  // propagate_const<T> has no reset() function
     }

void ServicesManager::fillListOfMakers ( std::vector< ParameterSet > & iConfiguration )

private

Definition at line 220 of file ServicesManager.cc.

References newFWLiteAna::base, edm::errors::Configuration, beamerCreator::create(), Exception, timingPdfMaker::get, registry_, requestedCreationOrder_, AlCaHLTBitMon_QueryRunRegistry::string, and type2Maker_.

Referenced by put(), and ServicesManager().

                                                                                   {
       for (std::vector<ParameterSet>::iterator itParam = iConfiguration.begin(), itParamEnd = iConfiguration.end();
            itParam != itParamEnd;
            ++itParam) {
         std::shared_ptr<ServiceMakerBase> base(
             ServicePluginFactory::get()->create(itParam->getParameter<std::string>("@service_type")));
 
         if (nullptr == base.get()) {
           throw Exception(errors::Configuration, "Service")
               << "could not find a service named " << itParam->getParameter<std::string>("@service_type")
               << ". Please check spelling.";
         }
         Type2Maker::iterator itFound = type2Maker_->find(TypeIDBase(base->serviceType()));
         if (itFound != type2Maker_->end()) {
           throw Exception(errors::Configuration, "Service")
               << " the service " << itParam->getParameter<std::string>("@service_type")
               << " provides the same service as " << itFound->second.pset_->getParameter<std::string>("@service_type")
               << "\n Please reconfigure job to only use one of these services.";
         }
         type2Maker_->insert(
             Type2Maker::value_type(TypeIDBase(base->serviceType()), MakerHolder(base, *itParam, registry_)));
         requestedCreationOrder_.push_back(TypeIDBase(base->serviceType()));
       }
     }

template<typename T >

T& edm::serviceregistry::ServicesManager::get ( ) const

inline

Definition at line 72 of file ServicesManager.h.

References createServiceFor(), edm::propagate_const< T >::get(), Skims_PA_cff::name, edm::errors::NotFound, edm::Exception::throwThis(), type2Maker_, and type2Service_.

Referenced by Options.Options::__getitem__(), betterConfigParser.BetterConfigParser::__updateDict(), rrapi.RRApi::columns(), rrapi.RRApi::count(), rrapi.RRApi::data(), betterConfigParser.BetterConfigParser::getCompares(), betterConfigParser.BetterConfigParser::getGeneral(), betterConfigParser.BetterConfigParser::getResultingSection(), rrapi.RRApi::report(), rrapi.RRApi::reports(), rrapi.RRApi::tables(), rrapi.RRApi::tags(), rrapi.RRApi::templates(), and rrapi.RRApi::workspaces().

                      {
         Type2Service::const_iterator itFound = type2Service_.find(TypeIDBase(typeid(T)));
         Type2Maker::const_iterator itFoundMaker;
         if (itFound == type2Service_.end()) {
           //do on demand building of the service
           if (nullptr == type2Maker_.get() ||
               type2Maker_->end() == (itFoundMaker = type2Maker_->find(TypeIDBase(typeid(T))))) {
             Exception::throwThis(errors::NotFound,
                                  "Service Request unable to find requested service with compiler type name '",
                                  typeid(T).name(),
                                  "'.\n");
           } else {
             const_cast<ServicesManager&>(*this).createServiceFor(itFoundMaker->second);
             itFound = type2Service_.find(TypeIDBase(typeid(T)));
             //the 'add()' should have put the service into the list
             assert(itFound != type2Service_.end());
           }
         }
         //convert it to its actual type
         std::shared_ptr<ServiceWrapper<T>> ptr(std::dynamic_pointer_cast<ServiceWrapper<T>>(itFound->second));
         assert(nullptr != ptr.get());
         return ptr->get();
       }

template<typename T >

bool edm::serviceregistry::ServicesManager::isAvailable ( ) const

inline

returns true of the particular service is accessible

Definition at line 98 of file ServicesManager.h.

References createServiceFor(), edm::propagate_const< T >::get(), type2Maker_, and type2Service_.

                                {
         Type2Service::const_iterator itFound = type2Service_.find(TypeIDBase(typeid(T)));
         Type2Maker::const_iterator itFoundMaker;
         if (itFound == type2Service_.end()) {
           //do on demand building of the service
           if (nullptr == type2Maker_.get() ||
               type2Maker_->end() == (itFoundMaker = type2Maker_->find(TypeIDBase(typeid(T))))) {
             return false;
           } else {
             //Actually create the service in order to 'flush out' any
             // configuration errors for the service
             const_cast<ServicesManager&>(*this).createServiceFor(itFoundMaker->second);
             itFound = type2Service_.find(TypeIDBase(typeid(T)));
             //the 'add()' should have put the service into the list
             assert(itFound != type2Service_.end());
           }
         }
         return true;
       }

ServicesManager const& edm::serviceregistry::ServicesManager::operator= ( ServicesManager const & )

privatedelete

Referenced by put().

template<typename T >

bool edm::serviceregistry::ServicesManager::put ( std::shared_ptr< ServiceWrapper< T >> iPtr )

inline

returns false if put fails because a service of this type already exists

Definition at line 123 of file ServicesManager.h.

References actualCreationOrder_, connect(), connectTo(), copySlotsFrom(), copySlotsTo(), createServiceFor(), createServices(), fillListOfMakers(), operator=(), ServicesManager(), and type2Service_.

Referenced by edm::serviceregistry::ServiceMaker< T, TMaker >::make().

                                                       {
         Type2Service::const_iterator itFound = type2Service_.find(TypeIDBase(typeid(T)));
         if (itFound != type2Service_.end()) {
           return false;
         }
         type2Service_[TypeIDBase(typeid(T))] = iPtr;
         actualCreationOrder_.push_back(TypeIDBase(typeid(T)));
         return true;
       }