art::ServicesManager Class Reference

#include <ServicesManager.h>

Public Member Functions
	ServicesManager (fhicl::ParameterSet &&servicesPSet, ActivityRegistry &actReg, detail::SharedResources &resources)
	~ServicesManager ()
	ServicesManager (ServicesManager const &)=delete
	ServicesManager (ServicesManager &&)=delete
ServicesManager &	operator= (ServicesManager const &)=delete
ServicesManager &	operator= (ServicesManager &&)=delete
template<class T >
bool	isAvailable () const
void	getParameterSets (std::vector< fhicl::ParameterSet > &out) const
void	forceCreation ()
std::vector< std::string >	registerProducts (ProductDescriptions &productsToProduce, ProducingServiceSignals &signals, ProcessConfiguration const &pc)
template<typename T >
T &	get ()
template<typename T >
void	put (std::unique_ptr< T > &&premade_service)
template<typename SERVICE , typename... ARGS>
void	addSystemService (ARGS &&...args)

Private Attributes
ActivityRegistry &	actReg_
detail::SharedResources &	resources_
cet::LibraryManager	lm_ {Suffixes::service()}
std::map< TypeID, detail::ServiceCacheEntry >	services_ {}
std::vector< TypeID >	requestedCreationOrder_ {}
std::stack< std::shared_ptr< detail::ServiceWrapperBase > >	actualCreationOrder_ {}
std::vector< std::string >	configErrMsgs_ {}

Detailed Description

Definition at line 36 of file ServicesManager.h.

Constructor & Destructor Documentation

art::ServicesManager::ServicesManager ( fhicl::ParameterSet &&  servicesPSet, ActivityRegistry &  actReg, detail::SharedResources &  resources  )

explicit

Definition at line 103 of file ServicesManager.cc.

    : actReg_{actReg}, resources_{resources}
  {
    vector<ParameterSet> psets;
    {
      // Force presence of FileCatalogMetadata service.
      addService("FileCatalogMetadata", servicesPSet, psets);
      servicesPSet.erase("FileCatalogMetadata");
      // Force presence of DatabaseConnection service.
      addService("DatabaseConnection", servicesPSet, psets);
      servicesPSet.erase("DatabaseConnection");
      // Extract all
      for (auto const& key : servicesPSet.get_pset_names()) {
        addService(key, servicesPSet, psets);
      }
    }
    using SHBCREATOR_t = std::unique_ptr<detail::ServiceHelperBase> (*)();
    for (auto const& ps : psets) {
      auto const service_name = ps.get<string>("service_type");
      auto const service_provider =
        ps.get<string>("service_provider", service_name);
      // Get the helper from the library.
      unique_ptr<detail::ServiceHelperBase> service_helper{
        lm_.getSymbolByLibspec<SHBCREATOR_t>(service_provider,
                                             "create_service_helper")()};
      if (service_helper->is_interface()) {
        throw Exception(errors::LogicError)
          << "Service " << service_name << " (of type "
          << service_helper->get_typeid().className()
          << ")\nhas been registered as an interface in its header using\n"
          << "DECLARE_ART_SERVICE_INTERFACE.\n"
          << "Use DECLARE_ART_SERVICE OR DECLARE_ART_SERVICE_INTERFACE_IMPL\n"
          << "as appropriate. A true service interface should *not* be\n"
          << "compiled into a  _service.so plugin library.\n";
      }
      unique_ptr<detail::ServiceInterfaceHelper> iface_helper;
      if (service_helper->is_interface_impl()) { // Expect an interface helper
        iface_helper.reset(dynamic_cast<detail::ServiceInterfaceHelper*>(
          lm_
            .getSymbolByLibspec<SHBCREATOR_t>(service_provider,
                                              "create_iface_helper")()
            .release()));
        if (dynamic_cast<detail::ServiceInterfaceImplHelper*>(
              service_helper.get())
              ->get_interface_typeid() != iface_helper->get_typeid()) {
          throw Exception(errors::LogicError)
            << "Service registration for " << service_provider
            << " is internally inconsistent: " << iface_helper->get_typeid()
            << " (" << iface_helper->get_typeid().className() << ") != "
            << dynamic_cast<detail::ServiceInterfaceImplHelper*>(
                 service_helper.get())
                 ->get_interface_typeid()
            << " ("
            << dynamic_cast<detail::ServiceInterfaceImplHelper*>(
                 service_helper.get())
                 ->get_interface_typeid()
                 .className()
            << ").\n"
            << "Contact the art developers <artists@fnal.gov>.\n";
        }
        if (service_provider == service_name) {
          string iface_name{
            cet::demangle_symbol(iface_helper->get_typeid().name())};
          // Remove any namespace qualification if necessary
          auto const colon_pos = iface_name.find_last_of(":");
          if (colon_pos != std::string::npos) {
            iface_name.erase(0, colon_pos + 1);
          }
          throw Exception(errors::Configuration)
            << "Illegal use of service interface implementation as service "
               "name in configuration.\n"
            << "Correct use: services." << iface_name
            << ": { service_provider: \"" << service_provider << "\" }\n";
        }
      }
      // Insert the cache entry for the main service implementation. Note
      // we save the typeid of the implementation because we're about to
      // give away the helper.
      TypeID service_typeid{service_helper->get_typeid()};

      // Need temporary because we can't guarantee the order of evaluation
      // of the arguments to make_pair() below.
      TypeID const sType{service_helper->get_typeid()};
      auto svc = services_.emplace(
        sType, detail::ServiceCacheEntry(ps, move(service_helper)));

      if (iface_helper) {
        // Need temporary because we can't guarantee the order of evaluation
        // of the arguments to make_pair() below.
        TypeID const iType{iface_helper->get_typeid()};
        services_.emplace(
          iType,
          detail::ServiceCacheEntry(ps, move(iface_helper), svc.first->second));
      }
      requestedCreationOrder_.emplace_back(move(service_typeid));
    }
    ServiceRegistry::instance().setManager(this);
  }

art::ServicesManager::~ServicesManager

(

)

Definition at line 55 of file ServicesManager.cc.

  {
    // Force the Service destructors to execute in the reverse order
    // of construction.  We first clear the the services cache, which
    // is safe to do as the services owned by it are co-owned by the
    // actualCreationOrder_ data member.
    services_.clear();
    while (!actualCreationOrder_.empty()) {
      actualCreationOrder_.pop();
    }
  }

art::ServicesManager::ServicesManager ( ServicesManager const &  )

delete

art::ServicesManager::ServicesManager ( ServicesManager &&  )

delete

Member Function Documentation

template<typename SERVICE , typename... ARGS>

void art::ServicesManager::addSystemService

(

ARGS &&...

args

)

Definition at line 123 of file ServicesManager.h.

                                                      {
    put(std::make_unique<SERVICE>(std::forward<ARGS>(args)...));
  }
  catch (fhicl::detail::validationException const& e) {
    constexpr cet::HorizontalRule rule{100};
    throw Exception(errors::Configuration)
      << "\n"
      << rule('=') << "\n\n"
      << "!! The following service has been misconfigured: !!"
      << "\n\n"
      << rule('-') << "\n\nservice_type: "
      << cet::bold_fontify(cet::demangle_symbol(typeid(SERVICE).name()))
      << "\n\n"
      << e.what() << "\n"
      << rule('=') << "\n\n";
  }

void art::ServicesManager::forceCreation

(

)

Definition at line 216 of file ServicesManager.cc.

  {
    for (auto const& typeID : requestedCreationOrder_) {
      if (auto it = services_.find(typeID); it != services_.end()) {
        auto const& sce = it->second;
        sce.forceCreation(actReg_, resources_);
      }
    }
  }

template<typename T >

T & art::ServicesManager::get

(

)

Definition at line 88 of file ServicesManager.h.

  {
    auto it = services_.find(TypeID{typeid(T)});
    if (it == services_.end()) {
      throw Exception(errors::ServiceNotFound)
        << "ServicesManager unable to find the service of type '"
        << cet::demangle_symbol(typeid(T).name()) << "'.\n";
    }
    return it->second.get<T>(actReg_, resources_, actualCreationOrder_);
  }

void art::ServicesManager::getParameterSets

(

std::vector< fhicl::ParameterSet > &

out

)

const

Definition at line 205 of file ServicesManager.cc.

  {
    std::vector<fhicl::ParameterSet> tmp;
    for (auto const& typeID_and_ServiceCacheEntry : services_) {
      auto const& sce = typeID_and_ServiceCacheEntry.second;
      tmp.push_back(sce.getParameterSet());
    }
    tmp.swap(out);
  }

template<class T >

bool art::ServicesManager::isAvailable ( ) const

inline

Definition at line 50 of file ServicesManager.h.

    {
      return services_.find(TypeID{typeid(T)}) != cend(services_);
    }

ServicesManager& art::ServicesManager::operator= ( ServicesManager const &  )

delete

ServicesManager& art::ServicesManager::operator= ( ServicesManager &&  )

delete

template<typename T >

void art::ServicesManager::put

(

std::unique_ptr< T > &&

premade_service

)

Definition at line 101 of file ServicesManager.h.

  {
    std::unique_ptr<detail::ServiceHelperBase> service_helper(
      new detail::ServiceHelper<T>);
    TypeID const id{typeid(T)};
    auto it = services_.find(id);
    if (it != services_.end()) {
      throw Exception(errors::LogicError, "Service")
        << "The system has manually added service of type "
        << cet::demangle_symbol(id.name())
        << ", but the service system already has a configured service of that "
           "type\n";
    }
    detail::WrapperBase_ptr swb{
      new detail::ServiceWrapper<T>(std::move(premade_service))};
    actualCreationOrder_.push(swb);
    services_.emplace(
      id, detail::ServiceCacheEntry(std::move(swb), std::move(service_helper)));
  }

std::vector< std::string > art::ServicesManager::registerProducts	(	ProductDescriptions &	productsToProduce,
		ProducingServiceSignals &	signals,
		ProcessConfiguration const &	pc
	)

Definition at line 68 of file ServicesManager.cc.

  {
    std::vector<std::string> producing_services;
    for (auto& pr : services_) {
      auto& serviceEntry = pr.second;

      // Service interfaces cannot be used for product insertion.
      if (serviceEntry.is_interface())
        continue;

      // The value of service_type becomes the "module name/label" for
      // the ModuleDescription object.
      auto const& pset = serviceEntry.getParameterSet();
      std::string moduleLabel{};
      if (!pset.get_if_present("service_type", moduleLabel)) {
        // System services do not insert products.
        continue;
      }

      auto const before = productsToProduce.size();
      ModuleDescription const md{
        pset.id(), moduleLabel, moduleLabel, ModuleThreadingType::shared, pc};
      serviceEntry.registerProducts(productsToProduce, signals, md);
      if (productsToProduce.size() != before) {
        // Registering the products for this service has changed the
        // size of productsToProduce.  We make the reasonable
        // assumption that productsToProduce has increased in size.
        producing_services.push_back(moduleLabel);
      }
    }
    return producing_services;
  }

Member Data Documentation

ActivityRegistry& art::ServicesManager::actReg_

private

Definition at line 76 of file ServicesManager.h.

std::stack<std::shared_ptr<detail::ServiceWrapperBase> > art::ServicesManager::actualCreationOrder_ {}

private

Definition at line 82 of file ServicesManager.h.

std::vector<std::string> art::ServicesManager::configErrMsgs_ {}

private

Definition at line 83 of file ServicesManager.h.

cet::LibraryManager art::ServicesManager::lm_ {Suffixes::service()}

private

Definition at line 78 of file ServicesManager.h.

std::vector<TypeID> art::ServicesManager::requestedCreationOrder_ {}

private

Definition at line 80 of file ServicesManager.h.

detail::SharedResources& art::ServicesManager::resources_

private

Definition at line 77 of file ServicesManager.h.

std::map<TypeID, detail::ServiceCacheEntry> art::ServicesManager::services_ {}

private

Definition at line 79 of file ServicesManager.h.

---

The documentation for this class was generated from the following files:

• art/art/Framework/Services/Registry/ServicesManager.h
• art/art/Framework/Services/Registry/ServicesManager.cc