art::ServicesManager Class Reference

#include "ServicesManager.h"

Public Types
using	ParameterSets = std::vector< fhicl::ParameterSet >

Public Member Functions
	ServicesManager (ServicesManager const &)=delete
ServicesManager &	operator= (ServicesManager const &)=delete
	ServicesManager (ParameterSets const &, cet::LibraryManager const &, ActivityRegistry &)
	~ServicesManager ()
template<typename T , typename = std::enable_if_t<detail::ServiceHelper<T>::scope_val != ServiceScope::PER_SCHEDULE>>
T &	get ()
template<typename T , typename = std::enable_if_t<detail::ServiceHelper<T>::scope_val == ServiceScope::PER_SCHEDULE>>
T &	get (ScheduleID)
template<class T >
bool	isAvailable () const
template<typename T , typename = std::enable_if_t<detail::ServiceHelper<T>::scope_val != ServiceScope::PER_SCHEDULE>>
void	put (std::unique_ptr< T > &&premade_service)
template<typename SP , typename = std::enable_if_t< detail::ServiceHelper<typename SP::element_type>::scope_val == ServiceScope::PER_SCHEDULE>>
void	put (std::vector< SP > &&premade_services)
void	forceCreation ()
void	registerProducts (MasterProductRegistry &mpr, ProductDescriptions &productsToProduce, ProducingServiceSignals &signals, ProcessConfiguration const &pc)
void	getParameterSets (ParameterSets &out) const

Private Types
using	SHBCREATOR_t) = std::unique_ptr< detail::ServiceHelperBase >(*)(
using	NameIndex = std::map< std::string, detail::ServiceCache::iterator >
using	TypeIDs = std::vector< TypeID >

Private Member Functions
void	fillCache_ (ParameterSets const &psets, cet::LibraryManager const &lm)
std::pair< detail::ServiceCache::iterator, bool >	insertImpl_ (fhicl::ParameterSet const &pset, std::unique_ptr< detail::ServiceHelperBase > &&helper)
void	insertInterface_ (fhicl::ParameterSet const &pset, std::unique_ptr< detail::ServiceHelperBase > &&helper, detail::ServiceCache::iterator implEntry)

Private Attributes
art::ActivityRegistry &	registry_
detail::ServiceCache	factory_ {}
NameIndex	index_ {}
TypeIDs	requestedCreationOrder_ {}
detail::ServiceStack	actualCreationOrder_ {}
std::vector< std::string >	configErrMsgs_ {}

Detailed Description

Definition at line 42 of file ServicesManager.h.

Member Typedef Documentation

using art::ServicesManager::NameIndex = std::map<std::string, detail::ServiceCache::iterator>

private

Definition at line 100 of file ServicesManager.h.

using art::ServicesManager::ParameterSets = std::vector<fhicl::ParameterSet>

Definition at line 48 of file ServicesManager.h.

using art::ServicesManager::SHBCREATOR_t = std::unique_ptr<detail::ServiceHelperBase> (*)(

private

Definition at line 99 of file ServicesManager.h.

using art::ServicesManager::TypeIDs = std::vector<TypeID>

private

Definition at line 101 of file ServicesManager.h.

Constructor & Destructor Documentation

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

delete

art::ServicesManager::ServicesManager ( ParameterSets const &  psets, cet::LibraryManager const &  lm, ActivityRegistry &  reg  )

explicit

Definition at line 18 of file ServicesManager.cc.

References fillCache_().

  : registry_{reg}
{
  fillCache_(psets, lm);
}

art::ServicesManager::~ServicesManager

(

)

Definition at line 26 of file ServicesManager.cc.

References actualCreationOrder_, factory_, and index_.

{
  // 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 may 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 fw executable is
  // destroyed in the desired order).
  index_.clear();
  factory_.clear();
  while (!actualCreationOrder_.empty()) {
    actualCreationOrder_.pop();
  }
}

Member Function Documentation

void art::ServicesManager::fillCache_ ( ParameterSets const &  psets, cet::LibraryManager const &  lm  )

private

Definition at line 99 of file ServicesManager.cc.

References art::errors::Configuration, index_, insertImpl_(), insertInterface_(), art::errors::LogicError, requestedCreationOrder_, and art::detail::ServiceCacheEntry::setNSchedules().

Referenced by ServicesManager().

{
  // Receive from EventProcessor when we go multi-schedule.
  detail::ServiceCacheEntry::setNSchedules(1);
  // Loop over each configured service parameter set.
  for (auto const& ps : psets) {
    std::string const service_name{ps.get<std::string>("service_type")};
    std::string const service_provider{
      ps.get<std::string>("service_provider", service_name)};
    // Get the helper from the library.
    std::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";
    }
    std::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) {
        std::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()};
    auto svc = insertImpl_(ps, std::move(service_helper));
    if (iface_helper) {
      insertInterface_(ps, std::move(iface_helper), svc.first);
    }
    index_[service_name] = svc.first;
    requestedCreationOrder_.emplace_back(std::move(service_typeid));
  }
} // fillCache()

void art::ServicesManager::forceCreation

(

)

Definition at line 46 of file ServicesManager.cc.

References factory_, registry_, and requestedCreationOrder_.

{
  for (auto const& val : requestedCreationOrder_) {
    auto c = factory_.find(val);
    if (c != factory_.end()) {
      c->second.forceCreation(registry_);
    }
    // JBK - should an exception be thrown if name not found in map?
  }
}

template<typename T , typename >

T & art::ServicesManager::get

(

)

Definition at line 128 of file ServicesManager.h.

References art::errors::ServiceNotFound.

{
  // Find the correct ServiceCacheEntry object.
  auto it = factory_.find(TypeID{typeid(T)});
  if (it == factory_.end())
    throw art::Exception(art::errors::ServiceNotFound)
      << "art::ServicesManager unable to find the service of type '"
      << cet::demangle_symbol(typeid(T).name()) << "'.\n";
  return it->second.get<T>(registry_, actualCreationOrder_);
} // get<>()

template<typename T , typename >

T & art::ServicesManager::get

(

ScheduleID

sID

)

Definition at line 141 of file ServicesManager.h.

References art::errors::ServiceNotFound.

{
  // Find the correct ServiceCacheEntry object.
  auto it = factory_.find(TypeID{typeid(T)});
  if (it == factory_.end())
    throw art::Exception(art::errors::ServiceNotFound)
      << "art::ServicesManager unable to find the service of type '"
      << cet::demangle_symbol(typeid(T).name()) << "'.\n";
  return it->second.get<T>(registry_, actualCreationOrder_, sID);
} // get<>()

void art::ServicesManager::getParameterSets

(

ParameterSets &

out

)

const

Definition at line 89 of file ServicesManager.cc.

References factory_, and tmp.

{
  ParameterSets tmp;
  for (auto const& cur : factory_) {
    tmp.push_back(cur.second.getParameterSet());
  }
  tmp.swap(out);
}

std::pair< art::detail::ServiceCache::iterator, bool > art::ServicesManager::insertImpl_ ( fhicl::ParameterSet const &  pset, std::unique_ptr< detail::ServiceHelperBase > &&  helper  )

private

Definition at line 176 of file ServicesManager.cc.

References factory_.

Referenced by fillCache_().

{
  // Need temporary because we can't guarantee the order of evaluation
  // of the arguments to emplace below.
  TypeID const sType{helper->get_typeid()};
  return factory_.emplace(sType,
                          detail::ServiceCacheEntry(pset, std::move(helper)));
}

void art::ServicesManager::insertInterface_ ( fhicl::ParameterSet const &  pset, std::unique_ptr< detail::ServiceHelperBase > &&  helper, detail::ServiceCache::iterator  implEntry  )

private

Definition at line 188 of file ServicesManager.cc.

References factory_.

Referenced by fillCache_().

{
  // Need temporary because we can't guarantee the order of evaluation
  // of the arguments to emplace below.
  TypeID const iType{helper->get_typeid()};
  factory_.emplace(
    iType,
    detail::ServiceCacheEntry(pset, std::move(helper), implEntry->second));
}

template<class T >

bool art::ServicesManager::isAvailable ( ) const

inline

Definition at line 69 of file ServicesManager.h.

  {
    return factory_.find(TypeID(typeid(T))) != factory_.end();
  }

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

delete

template<typename T , typename >

void art::ServicesManager::put

(

std::unique_ptr< T > &&

premade_service

)

Definition at line 154 of file ServicesManager.h.

References art::errors::LogicError.

{
  std::unique_ptr<detail::ServiceHelperBase> service_helper(
    new detail::ServiceHelper<T>);
  TypeID const id{typeid(T)};
  detail::ServiceCache::const_iterator it = factory_.find(id);
  if (it != factory_.end()) {
    throw art::Exception(art::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, detail::ServiceHelper<T>::scope_val>(
      std::move(premade_service)));
  actualCreationOrder_.push(swb);
  factory_.emplace(
    id, detail::ServiceCacheEntry(std::move(swb), std::move(service_helper)));
}

template<typename SP , typename >

void art::ServicesManager::put

(

std::vector< SP > &&

premade_services

)

Definition at line 177 of file ServicesManager.h.

References art::errors::LogicError.

{
  using element_type = typename SP::element_type;
  std::unique_ptr<detail::ServiceHelperBase> service_helper(
    new detail::ServiceHelper<element_type>);
  TypeID const id{typeid(element_type)};
  detail::ServiceCache::const_iterator it = factory_.find(id);
  if (it != factory_.end()) {
    throw art::Exception(art::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<element_type,
                               detail::ServiceHelper<element_type>::scope_val>(
      std::move(premade_services)));
  actualCreationOrder_.push(swb);
  factory_.emplace(
    id, detail::ServiceCacheEntry(std::move(swb), std::move(service_helper)));
}

void art::ServicesManager::registerProducts	(	MasterProductRegistry &	mpr,
		ProductDescriptions &	productsToProduce,
		ProducingServiceSignals &	signals,
		ProcessConfiguration const &	pc
	)

Definition at line 58 of file ServicesManager.cc.

References factory_, art::ModuleDescription::id(), and art::PER_SCHEDULE.

{
  for (auto& pr : factory_) {
    auto& serviceEntry = pr.second;

    // Per-schedule services cannot register products
    if (serviceEntry.serviceScope() == ServiceScope::PER_SCHEDULE)
      continue;

    // 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;
    }

    ModuleDescription const md{pset.id(), moduleLabel, moduleLabel, pc};
    serviceEntry.registerProducts(mpr, productsToProduce, signals, md);
  }
}

Member Data Documentation

detail::ServiceStack art::ServicesManager::actualCreationOrder_ {}

private

Definition at line 119 of file ServicesManager.h.

Referenced by ~ServicesManager().

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

private

Definition at line 120 of file ServicesManager.h.

detail::ServiceCache art::ServicesManager::factory_ {}

private

Definition at line 115 of file ServicesManager.h.

Referenced by forceCreation(), getParameterSets(), insertImpl_(), insertInterface_(), registerProducts(), and ~ServicesManager().

NameIndex art::ServicesManager::index_ {}

private

Definition at line 116 of file ServicesManager.h.

Referenced by fillCache_(), and ~ServicesManager().

art::ActivityRegistry& art::ServicesManager::registry_

private

Definition at line 114 of file ServicesManager.h.

Referenced by forceCreation().

TypeIDs art::ServicesManager::requestedCreationOrder_ {}

private

Definition at line 118 of file ServicesManager.h.

Referenced by fillCache_(), and forceCreation().

---

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

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