ToolHandle.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_TOOLHANDLE_H
#define GAUDIKERNEL_TOOLHANDLE_H

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

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

// 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);
  }

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

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

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

protected:

  virtual const IAlgTool * getAsIAlgTool() const = 0;

  virtual IAlgTool * getAsIAlgTool() = 0;

};

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>( GaudiHandle<T>::getDefaultType(),
                      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 = typename std::enable_if<std::is_base_of<IProperty, OWNER>::value>::type>
  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 is not specified use only name
    // - if type does not contain '/' use type/name
    // - otherwise type is already a type/name string
    if ( toolType.empty() ) {
      toolType = name;
    } else if ( 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 { // 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( this->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 GaudiHandle<T>::nonConst( GaudiHandle<T>::operator->() );
  }
  T & operator*() const {
    return * ( GaudiHandle<T>::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 this->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,
                    typename std::enable_if< std::is_const<CT>::value &&
                                             !std::is_same<CT,NCT>::value >::type * = 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 is not specified use only name
    // - if type does not contain '/' use type/name
    // - otherwise type is already a type/name string
    if ( toolType.empty() ) {
      toolType = name;
    } else if ( 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 = typename std::enable_if<std::is_base_of<IProperty, OWNER>::value>::type>
  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