ToolHandle.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_TOOLHANDLE_H
#define GAUDIKERNEL_TOOLHANDLE_H

// Includes
#include "GaudiKernel/GaudiHandle.h"
#include "GaudiKernel/IAlgTool.h"
#include "GaudiKernel/INamedInterface.h"
#include "GaudiKernel/IToolSvc.h"
#include "GaudiKernel/ServiceHandle.h"

#include <stdexcept>
#include <string>
#include <type_traits>
#include <vector>

// forward declarations
class IInterface;
class IToolSvc;

class Algorithm;
class AlgTool;
class Service;

class ToolHandleInfo
{

protected:
  ToolHandleInfo( const IInterface* parent = nullptr, bool createIf = true )
      : m_parent( parent ), m_createIf( createIf )
  {
  }

public:
  virtual ~ToolHandleInfo() = default;

  bool isPublic() const noexcept { return !m_parent; }

  bool createIf() const noexcept { return m_createIf; }

  const IInterface* parent() const noexcept { return m_parent; }

  //
  // Some helper functions
  //

  static std::string toolComponentType( const IInterface* parent ) { return parent ? "PrivateTool" : "PublicTool"; }

  static std::string toolParentName( const IInterface* parent )
  {
    auto* pNamed = ( parent ? dynamic_cast<const INamedInterface*>( parent ) : nullptr );
    return ( !parent ? "ToolSvc" : ( pNamed ? pNamed->name() : "" ) );
  }

protected:
  const IInterface* m_parent = nullptr;
  bool m_createIf{true};
};

class BaseToolHandle : public ToolHandleInfo
{

protected:
  BaseToolHandle( const IInterface* parent = nullptr, bool createIf = true ) : ToolHandleInfo( parent, createIf ) {}

  virtual StatusCode i_retrieve( IAlgTool*& ) const = 0;

public:
  StatusCode retrieve( IAlgTool*& tool ) const { return i_retrieve( tool ); }

  virtual StatusCode retrieve() const = 0;

  const IAlgTool* get() const { return getAsIAlgTool(); }

  IAlgTool* get() { return getAsIAlgTool(); }

  virtual std::string typeAndName() const = 0;

  inline bool isEnabled() const
  {
    // the handle is considered enabled if the type/name is valid and the
    // enabled flag was set to true, or it was already retrieved
    return ( m_enabled && !typeAndName().empty() ) || get();
  }

  inline void enable() { m_enabled = true; }

  inline void disable() { m_enabled = false; }

  inline bool setEnabled( const bool flag )
  {
    auto old  = m_enabled;
    m_enabled = flag;
    return old;
  }

protected:
  virtual const IAlgTool* getAsIAlgTool() const = 0;

  virtual IAlgTool* getAsIAlgTool() = 0;

  bool m_enabled = true;
};

template <class T>
class ToolHandle : public BaseToolHandle, public GaudiHandle<T>
{

  friend class Algorithm;
  friend class AlgTool;
  friend class Service;

public:
  ToolHandle( const IInterface* parent = nullptr, bool createIf = true )
      : BaseToolHandle( parent, createIf )
      , GaudiHandle<T>( "", toolComponentType( parent ), toolParentName( parent ) )
      , m_pToolSvc( "ToolSvc", GaudiHandleBase::parentName() )
  {
  }

  template <typename CT = T, typename NCT = typename std::remove_const<T>::type>
  ToolHandle( const ToolHandle<NCT>& other,
              typename std::enable_if<std::is_const<CT>::value && !std::is_same<CT, NCT>::value>::type* = nullptr )
      : BaseToolHandle( other.parent(), other.createIf() )
      , GaudiHandle<CT>( other )
      , m_pToolSvc( "ToolSvc", GaudiHandleBase::parentName() )
  {
  }

public:
//
// Constructors etc.
//

#if defined( TOOLHANDLE_DEPR_WARN )
// warn about using deprecated explicit ToolHandle construction
#pragma message( "Untracked ToolHandle: Migrate explicit DataHandle constructor to declareTool Algorithm Property" )

  __attribute__( ( deprecated ) )

#endif
  ToolHandle( const std::string& toolTypeAndName, const IInterface* parent = nullptr, bool createIf = true )
      : BaseToolHandle( parent, createIf )
      , GaudiHandle<T>( toolTypeAndName, toolComponentType( parent ), toolParentName( parent ) )
      , m_pToolSvc( "ToolSvc", GaudiHandleBase::parentName() )
  {
  }

  template <class OWNER, typename = std::enable_if_t<std::is_base_of<IProperty, OWNER>::value>>
  inline ToolHandle( OWNER* owner, std::string name, std::string toolType, std::string doc = "" ) : ToolHandle( owner )
  {
    // convert name and type to a valid type/name string
    // - if type does not contain '/' use type/name
    // - otherwise type is already a type/name string
    if ( !toolType.empty() and toolType.find( '/' ) == std::string::npos ) {
      toolType += '/';
      toolType += name;
    }
    owner->declareTool( *this, std::move( toolType ) ).ignore();
    auto p = owner->OWNER::PropertyHolderImpl::declareProperty( std::move( name ), *this, std::move( doc ) );
    p->template setOwnerType<OWNER>();
  }

public:
  StatusCode initialize( const std::string& toolTypeAndName, const IInterface* parent = nullptr, bool createIf = true )
  {

    GaudiHandleBase::setTypeAndName( toolTypeAndName );
    GaudiHandleBase::setComponentType( toolComponentType( parent ) );
    GaudiHandleBase::setParentName( toolParentName( parent ) );

    m_parent   = parent;
    m_createIf = createIf;

    return m_pToolSvc.initialize( "ToolSvc", GaudiHandleBase::parentName() );
  }

  StatusCode retrieve() const override
  { // not really const, because it updates m_pObject
    return GaudiHandle<T>::retrieve();
  }

  StatusCode release() const
  { // not really const, because it updates m_pObject
    return GaudiHandle<T>::release();
  }

  StatusCode retrieve( T*& algTool ) const override
  {
    IAlgTool* iface = nullptr;
    algTool         = i_retrieve( iface ) ? dynamic_cast<T*>( iface ) : nullptr;
    return algTool ? StatusCode::SUCCESS : StatusCode::FAILURE;
  }

  StatusCode release( T* algTool ) const override { return m_pToolSvc->releaseTool( details::nonConst( algTool ) ); }

  std::string typeAndName() const override { return GaudiHandleBase::typeAndName(); }

  typename std::add_const<T>::type* get() const { return GaudiHandle<T>::get(); }

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

// Allow access to non-const Tool methods of const ToolHandle
#ifdef ALLOW_TOOLHANDLE_NONCONSTNESS
  T* operator->() { return GaudiHandle<T>::operator->(); }
  T& operator*() { return *( GaudiHandle<T>::operator->() ); }

  T* operator->() const { return details::nonConst( GaudiHandle<T>::operator->() ); }
  T& operator*() const { return *( details::nonConst( GaudiHandle<T>::operator->() ) ); }
#endif

#ifdef ATLAS
  [[deprecated( "FIXME!! should not call non-const method from a const ToolHandle" )]] ToolHandle<T>& unConst() const
  {
    return const_cast<ToolHandle<T>&>( *this );
  }
#endif

protected:
  const IAlgTool* getAsIAlgTool() const override
  {
    // const cast to support T being const
    return GaudiHandle<T>::get();
  }

  IAlgTool* getAsIAlgTool() override
  {
    // const cast to support T being const
    return details::nonConst( GaudiHandle<T>::get() );
  }

  StatusCode i_retrieve( IAlgTool*& algTool ) const override
  {
    return m_pToolSvc->retrieve( typeAndName(), IAlgTool::interfaceID(), algTool, ToolHandleInfo::parent(),
                                 ToolHandleInfo::createIf() );
  }

private:
  //
  // Private data members
  //
  mutable ServiceHandle<IToolSvc> m_pToolSvc;
};

template <class T>
class PublicToolHandle : public ToolHandle<T>
{
public:
  PublicToolHandle( bool createIf = true ) : ToolHandle<T>( nullptr, createIf ) {}
  PublicToolHandle( const char* toolTypeAndName, bool createIf = true )
      : PublicToolHandle{std::string{toolTypeAndName}, createIf}
  {
  }
  PublicToolHandle( const std::string& toolTypeAndName, bool createIf = true )
      : ToolHandle<T>( toolTypeAndName, nullptr, createIf )
  {
  }

  template <typename CT = T, typename NCT = typename std::remove_const<T>::type>
  PublicToolHandle( const PublicToolHandle<NCT>& other,
                    std::enable_if_t<std::is_const<CT>::value && !std::is_same<CT, NCT>::value>* = nullptr )
      : ToolHandle<T>( static_cast<const ToolHandle<NCT>&>( other ) )
  {
  }

  template <class OWNER, typename = typename std::enable_if<std::is_base_of<IProperty, OWNER>::value>::type>
  inline PublicToolHandle( OWNER* owner, std::string name, std::string toolType, std::string doc = "" )
      : PublicToolHandle()
  {
    // convert name and type to a valid type/name string
    // - if type does not contain '/' use type/name
    // - otherwise type is already a type/name string
    if ( !toolType.empty() and toolType.find( '/' ) == std::string::npos ) {
      toolType += '/';
      toolType += name;
    }
    owner->declareTool( *this, std::move( toolType ) ).ignore();
    auto p = owner->OWNER::PropertyHolderImpl::declareProperty( std::move( name ), *this, std::move( doc ) );
    p->template setOwnerType<OWNER>();
  }
};

//-------------------------------------------------------------------------//

template <class T>
class ToolHandleArray : public ToolHandleInfo, public GaudiHandleArray<ToolHandle<T>>
{
public:
  //
  // Constructors
  //
  ToolHandleArray( const std::vector<std::string>& myTypesAndNames, const IInterface* parent = nullptr,
                   bool createIf = true )
      : ToolHandleInfo( parent, createIf )
      , GaudiHandleArray<ToolHandle<T>>( myTypesAndNames, ToolHandleInfo::toolComponentType( parent ),
                                         ToolHandleInfo::toolParentName( parent ) )
  {
  }

  ToolHandleArray( const IInterface* parent = nullptr, bool createIf = true )
      : ToolHandleInfo( parent, createIf )
      , GaudiHandleArray<ToolHandle<T>>( ToolHandleInfo::toolComponentType( parent ),
                                         ToolHandleInfo::toolParentName( parent ) )
  {
  }

  bool push_back( const std::string& toolTypeAndName ) override
  {
    ToolHandle<T> handle( toolTypeAndName, ToolHandleInfo::parent(), ToolHandleInfo::createIf() );
    GaudiHandleArray<ToolHandle<T>>::push_back( handle );
    return true;
  }

  bool push_back( const ToolHandle<T>& myHandle ) override { return push_back( myHandle.typeAndName() ); }

  template <class OWNER, typename = std::enable_if_t<std::is_base_of<IProperty, OWNER>::value>>
  inline ToolHandleArray( OWNER* owner, std::string name, const std::vector<std::string>& typesAndNames = {},
                          std::string doc = "" )
      : ToolHandleArray( typesAndNames, owner )
  {
    owner->addToolsArray( *this );
    auto p = owner->OWNER::PropertyHolderImpl::declareProperty( std::move( name ), *this, std::move( doc ) );
    p->template setOwnerType<OWNER>();
  }
};

template <class T>
class PublicToolHandleArray : public ToolHandleArray<T>
{
public:
  PublicToolHandleArray( bool createIf = true ) : ToolHandleArray<T>( nullptr, createIf ) {}
  PublicToolHandleArray( const std::vector<std::string>& typesAndNames, bool createIf = true )
      : ToolHandleArray<T>( typesAndNames, nullptr, createIf )
  {
  }

  template <class OWNER, typename = typename std::enable_if<std::is_base_of<IProperty, OWNER>::value>::type>
  inline PublicToolHandleArray( OWNER* owner, std::string name, const std::vector<std::string>& typesAndNames = {},
                                std::string doc = "" )
      : PublicToolHandleArray( typesAndNames )
  {
    owner->addToolsArray( *this );
    auto p = owner->OWNER::PropertyHolderImpl::declareProperty( std::move( name ), *this, std::move( doc ) );
    p->template setOwnerType<OWNER>();
  }
};

template <class T>
inline std::ostream& operator<<( std::ostream& os, const ToolHandle<T>& handle )
{
  return operator<<( os, static_cast<const GaudiHandleInfo&>( handle ) );
}

template <class T>
inline std::ostream& operator<<( std::ostream& os, const ToolHandleArray<T>& handle )
{
  return operator<<( os, static_cast<const GaudiHandleInfo&>( handle ) );
}

#endif // ! GAUDIKERNEL_TOOLHANDLE_H