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.                                             *
\***********************************************************************************/
#ifndef GAUDIKERNEL_SERVICEHANDLE_H
#define GAUDIKERNEL_SERVICEHANDLE_H
 
// Includes
#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 predeclarations
class IAlgTool;
class IToolSvc;
class ServiceHandleProperty;
 
template <class T>
class ServiceHandle : public GaudiHandle<T> {
public:
  //
  // Constructors etc.
  //
  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;
 
  //  /** Release the Service.
  //    Function must be repeated here to avoid hiding the function release( T*& ) */
  //   StatusCode release() const { // not really const, because it updates m_pObject
  //     return GaudiHandle<T>::release();
  //   }
 
  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 { return i_retrieve( service ); }
 
  template <Gaudi::IsInterface I = T>
  StatusCode i_retrieve( I*& service ) const {
    const ServiceLocatorHelper helper( *serviceLocator(), GaudiHandleBase::messageName(), this->parentName() );
    return helper.getService( GaudiHandleBase::typeAndName(), true, I::interfaceID(), (void**)&service );
  }
 
  template <typename I = T>
    requires( !Gaudi::IsInterface<I> )
  StatusCode i_retrieve( I*& service ) const {
    IService* svc = nullptr;
    return i_retrieve( svc ).andThen( [&] {
      service = dynamic_cast<I*>( svc );
      if ( !service )
        throw GaudiException( "unable to dcast Service " + this->typeAndName() + " to " +
                                  System::typeinfoName( typeid( T ) ),
                              this->typeAndName() + " retrieve", StatusCode::FAILURE );
    } );
  }
 
  //   /** Do the real release of the Service */
  //   virtual StatusCode release( T* service ) const {
  //     return service->release();
  //   }
 
private:
  //
  // Private helper functions
  //
  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;
  }
  //
  // private data members
  //
  mutable SmartIF<ISvcLocator> m_pSvcLocator;
  mutable SmartIF<IMessageSvc> m_pMessageSvc;
};
 
template <class T>
class ServiceHandleArray : public GaudiHandleArray<ServiceHandle<T>> {
public:
  //
  // Constructors
  //
  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 ) );
}
 
#endif // ! GAUDIKERNEL_SERVICEHANDLE_H