ServiceHandle.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_SERVICEHANDLE_H
#define GAUDIKERNEL_SERVICEHANDLE_H

// Includes
#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 = typename std::remove_const<T>::type>
  ServiceHandle( const ServiceHandle<NCT>& other,
                 typename std::enable_if<std::is_const<CT>::value && !std::is_same<CT, NCT>::value>::type* = nullptr )
      : GaudiHandle<CT>( other )
  {
  }

  template <class OWNER, typename = typename std::enable_if<std::is_base_of<IProperty, OWNER>::value>::type>
  inline ServiceHandle( OWNER* owner, std::string PropName, 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;
  }

  StatusCode retrieve() const
  { // not really const, because it updates m_pObject
    return 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
  {
    const ServiceLocatorHelper helper( *serviceLocator(), GaudiHandleBase::messageName(), this->parentName() );
    return helper.getService( GaudiHandleBase::typeAndName(), true, T::interfaceID(), (void**)&service );
  }

  //   /** 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