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 { return !m_parent; }

  bool createIf() const { return m_createIf; }

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

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

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

protected:
  const IInterface* m_parent;
  bool m_createIf;

};

class BaseToolHandle: public ToolHandleInfo {

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

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

public:
  virtual ~BaseToolHandle() {}

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

  virtual IAlgTool* get() const = 0;
  virtual std::string typeAndName() const = 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() )
  {  }

 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() )
  {  }

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;

    StatusCode sc = m_pToolSvc.initialize("ToolSvc", GaudiHandleBase::parentName());

    return sc;
  }

  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( algTool );
  }

  IAlgTool *get() const override {
    return GaudiHandle<T>::get();
  }
  std::string typeAndName() const override {
    return GaudiHandleBase::typeAndName();
  }

protected:
  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 ToolHandleArray : public ToolHandleInfo, public GaudiHandleArray< ToolHandle<T> > {
public:
  //
  // Constructors
  //
  ToolHandleArray( const std::vector< std::string >& myTypesAndNames,
                   const IInterface* parent = 0, bool createIf = true )
    : ToolHandleInfo( parent, createIf ),
      GaudiHandleArray< ToolHandle<T> >( myTypesAndNames,
                                         ToolHandleInfo::toolComponentType(parent),
                                         ToolHandleInfo::toolParentName(parent) )
  {}

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

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

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

};


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