ServicesManager.h

Go to the documentation of this file.

#ifndef ServiceRegistry_ServicesManager_h
#define ServiceRegistry_ServicesManager_h
// -*- C++ -*-
//
// Package:     ServiceRegistry
// Class  :     ServicesManager
//
//
// Original Author:  Chris Jones
//         Created:  Mon Sep  5 13:33:01 EDT 2005
//

// user include files
#include "FWCore/ServiceRegistry/interface/ActivityRegistry.h"
#include "FWCore/ServiceRegistry/interface/ServiceLegacy.h"
#include "FWCore/ServiceRegistry/interface/ServiceMakerBase.h"
#include "FWCore/ServiceRegistry/interface/ServiceWrapper.h"
#include "FWCore/Utilities/interface/EDMException.h"
#include "FWCore/Utilities/interface/TypeIDBase.h"
#include "FWCore/Utilities/interface/propagate_const.h"

// system include files
#include <memory>

#include <cassert>
#include <vector>

// forward declarations
namespace edm {
   class ParameterSet;
   class ServiceToken;

   namespace serviceregistry {

      class ServicesManager {
public:
         struct MakerHolder {
            MakerHolder(std::shared_ptr<ServiceMakerBase> iMaker,
                        ParameterSet& iPSet,
                        ActivityRegistry&) ;
            bool add(ServicesManager&) const;

            edm::propagate_const<std::shared_ptr<ServiceMakerBase>> maker_;
            ParameterSet* pset_;
            ActivityRegistry* registry_; // We do not use propagate_const because the registry itself is mutable
            mutable bool wasAdded_;
         };
         typedef std::map<TypeIDBase, std::shared_ptr<ServiceWrapperBase> > Type2Service;
         typedef std::map<TypeIDBase, MakerHolder> Type2Maker;

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

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

         ~ServicesManager();

         // ---------- const member functions ---------------------
         template<typename T>
         T& get() const {
            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 isAvailable() const {
            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;
         }

         // ---------- static member functions --------------------

         // ---------- member functions ---------------------------
         template<typename T>
         bool put(std::shared_ptr<ServiceWrapper<T> > iPtr) {
            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;
         }

         void connect(ActivityRegistry& iOther);

         void connectTo(ActivityRegistry& iOther);

         void copySlotsTo(ActivityRegistry&);
         void copySlotsFrom(ActivityRegistry&);

private:
         ServicesManager(ServicesManager const&) = delete; // stop default

         ServicesManager const& operator=(ServicesManager const&) = delete; // stop default

         void fillListOfMakers(std::vector<ParameterSet>&);
         void createServices();
         void createServiceFor(MakerHolder const&);

         // ---------- member data --------------------------------
         //hold onto the Manager passed in from the ServiceToken so that
         // the ActivityRegistry of that Manager does not go out of scope
         // This must be first to get the Service destructors called in
         // the correct order.
         edm::propagate_const<std::shared_ptr<ServicesManager>> associatedManager_;

         ActivityRegistry registry_;
         Type2Service type2Service_;
         edm::propagate_const<std::unique_ptr<Type2Maker>> type2Maker_;
         std::vector<TypeIDBase> requestedCreationOrder_;
         std::vector<TypeIDBase> actualCreationOrder_;
      };
   }
}

#endif