ServiceHandle.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include <Gaudi/Concepts.h>
#include <GaudiKernel/Bootstrap.h>
#include <GaudiKernel/GaudiException.h>
#include <GaudiKernel/GaudiHandle.h>
#include <GaudiKernel/IMessageSvc.h>
#include <GaudiKernel/IProperty.h>
#include <GaudiKernel/ISvcLocator.h>
#include <GaudiKernel/MsgStream.h>
#include <GaudiKernel/ServiceLocatorHelper.h>
#include <stdexcept>
#include <string>
#include <type_traits>
 
class IAlgTool;
class IToolSvc;
class ServiceHandleProperty;

template <class T>
class ServiceHandle : public GaudiHandle<T> {
public:
  ServiceHandle( const std::string& serviceName, const std::string& theParentName )
      : GaudiHandle<T>( serviceName, "Service", theParentName ) {}

  template <typename CT = T, typename NCT = std::remove_const_t<T>>
    requires( std::is_const_v<CT> && !std::is_same_v<CT, NCT> )
  ServiceHandle( const ServiceHandle<NCT>& other ) : GaudiHandle<CT>( other ) {}

  template <std::derived_from<IProperty> OWNER>
  inline ServiceHandle( OWNER* owner, std::string PropName, const std::string& svcName, std::string doc = "" )
      : ServiceHandle( svcName, owner->name() ) {
    auto p = owner->OWNER::PropertyHolderImpl::declareProperty( std::move( PropName ), *this, std::move( doc ) );
    p->template setOwnerType<OWNER>();
  }
 
  StatusCode initialize( const std::string& serviceName, const std::string& theParentName ) {
 
    GaudiHandleBase::setTypeAndName( serviceName );
    GaudiHandleBase::setParentName( theParentName );
 
    return StatusCode::SUCCESS;
  }

  using GaudiHandle<T>::retrieve;

  T* get() const { return ::details::nonConst( GaudiHandle<T>::get() ); }

  T* operator->() const { return ::details::nonConst( GaudiHandle<T>::operator->() ); }
  T& operator*() const { return *::details::nonConst( GaudiHandle<T>::operator->() ); }
 
protected:
  StatusCode retrieve( T*& service ) const override {
    const ServiceLocatorHelper helper( *serviceLocator(), GaudiHandleBase::messageName(), this->parentName() );
    if ( auto svc = helper.service<T>( GaudiHandleBase::typeAndName(), /* quiet = */ true, /* createIf = */ true ) ) {
      svc->addRef();
      service = svc.get();
      return StatusCode::SUCCESS;
    }
    return StatusCode::FAILURE;
  }
 
private:
  SmartIF<ISvcLocator>& serviceLocator() const { // not really const, because it may change m_pSvcLocator
    if ( !m_pSvcLocator ) {
      m_pSvcLocator = Gaudi::svcLocator();
      if ( !m_pSvcLocator ) {
        throw GaudiException( "SvcLocator not found", "Core component not found", StatusCode::FAILURE );
      }
    }
    return m_pSvcLocator;
  }
 
  SmartIF<IMessageSvc>& messageSvc() const { // not really const, because it may change m_pMessageSvc
    if ( !m_pMessageSvc ) {
      m_pMessageSvc = serviceLocator(); // default message service
      if ( !m_pMessageSvc ) {
        throw GaudiException( "Service [MessageSvc] not found", this->parentName(), StatusCode::FAILURE );
      }
    }
    return m_pMessageSvc;
  }
 
  mutable SmartIF<ISvcLocator> m_pSvcLocator;
  mutable SmartIF<IMessageSvc> m_pMessageSvc;
};

 
template <class T>
class ServiceHandleArray : public GaudiHandleArray<ServiceHandle<T>> {
public:
  ServiceHandleArray( const std::vector<std::string>& myTypesAndNamesList, const std::string& myComponentType,
                      const std::string& myParentName )
      : GaudiHandleArray<ServiceHandle<T>>( myTypesAndNamesList, myComponentType, myParentName ) {}
 
  virtual ~ServiceHandleArray() {}
 
  ServiceHandleArray( const std::string& myParentName )
      : GaudiHandleArray<ServiceHandle<T>>( "Service", myParentName ) {}
 
  virtual bool push_back( const std::string& serviceTypeAndName ) {
    ServiceHandle<T> handle( serviceTypeAndName, GaudiHandleInfo::parentName() );
    GaudiHandleArray<ServiceHandle<T>>::push_back( handle );
    return true;
  }
 
  virtual bool push_back( const ServiceHandle<T>& myHandle ) { return push_back( myHandle.typeAndName() ); }
};
 
template <class T>
inline std::ostream& operator<<( std::ostream& os, const ServiceHandle<T>& handle ) {
  return operator<<( os, static_cast<const GaudiHandleInfo&>( handle ) );
}
 
template <class T>
inline std::ostream& operator<<( std::ostream& os, const ServiceHandleArray<T>& handle ) {
  return operator<<( os, static_cast<const GaudiHandleInfo&>( handle ) );
}