AsgServiceConfig.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
 
 
 
#ifndef ASG_SERVICES_ASG_SERVICE_CONFIG_H
#define ASG_SERVICES_ASG_SERVICE_CONFIG_H
 
#include <AsgTools/AsgComponentConfig.h>
#include <AsgServices/AsgService.h>
#include <AsgServices/ServiceHandle.h>
 
#ifndef XAOD_STANDALONE
#include <GaudiKernel/Service.h>
#endif
 
namespace asg
{
 
  class AsgServiceConfig : public asg::AsgComponentConfig
  {
    //
    // public interface
    //
 
  public:
    AsgServiceConfig () = default;
 
 
  public:
    explicit AsgServiceConfig (const std::string& val_typeAndName);
 
 
  public:
    explicit AsgServiceConfig (const AsgComponentConfig& val_config);
 
 
  public:
    virtual ~AsgServiceConfig () = default;
 
 
  public:
    template<typename T> ::StatusCode
    makeService (std::shared_ptr<T>& service) const;
    template<typename T> ::StatusCode
    makeService (ServiceHandle<T>& service) const;
 
 
 
    //
    // private interface
    //
  };
 
 
 
  //
  // template methods
  //
 
#ifdef XAOD_STANDALONE
 
  template<typename T> ::StatusCode AsgServiceConfig ::
  makeService (std::shared_ptr<T>& service) const
  {
    using namespace msgComponentConfig;
 
    std::unique_ptr<T> myservice;
    ANA_CHECK (makeComponentExpert (myservice, "new %1% (\"%2%\", nullptr)", false, ""));
    AsgService *asgService = dynamic_cast<AsgService*>(myservice.get());
    ANA_CHECK (asgService->initialize());
 
    service = std::move (myservice);
    ANA_CHECK (ServiceStore::put (service));
 
    ANA_MSG_DEBUG ("Created component of type " << type());
    return StatusCode::SUCCESS;
  }
 
  template<typename T> ::StatusCode AsgServiceConfig ::
  makeService (ServiceHandle<T>& service) const
  {
    using namespace msgComponentConfig;
 
    std::shared_ptr<T> myservice;
    ANA_CHECK (makeService (myservice));
    service = ServiceHandle (myservice, service.parentName());
    return StatusCode::SUCCESS;
  }
 
#else
 
  template<typename T> ::StatusCode AsgServiceConfig ::
  makeService (std::shared_ptr<T>& service) const
  {
    using namespace msgComponentConfig;
 
    ServiceHandle<T> serviceHandle (typeAndName(), "AsgServiceConfig");
    ANA_CHECK (makeService (serviceHandle));
 
    // This creates an unmanaged shared pointer, i.e. a pointer that
    // doesn't actually own the pointed to object, it will neither
    // guarantee to keep the object around until its own destruction,
    // nor will it ever trigger a destruction of the object on its own
    // destruction.  Since the athena framework will keep the services
    // around until the end of the job, that ought to be safe if used
    // as advertised.
    service = std::shared_ptr<T> (std::shared_ptr<void>(), &*serviceHandle);
 
    ANA_MSG_DEBUG ("Created component of type " << type());
    return StatusCode::SUCCESS;
  }
 
  template<typename T> ::StatusCode AsgServiceConfig ::
  makeService (ServiceHandle<T>& service) const
  {
    using namespace msgComponentConfig;
 
    ANA_CHECK (configureComponentExpert ("", false));
    service.setTypeAndName (typeAndName());
    ANA_CHECK (service.retrieve());
    if (auto svc = dynamic_cast<::AthService*> (service.get())) {
      ANA_CHECK (svc->sysInitialize());
    }
    else {
      ANA_MSG_ERROR ("Cannot cast to AthService");
      return StatusCode::FAILURE;
    }
 
    ANA_MSG_DEBUG ("Created component of type " << type());
    return StatusCode::SUCCESS;
  }
 
#endif
 
}
 
#endif