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/SmartIF.h"

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

// forward declarations
class IInterface;
class IAlgTool;
class IToolSvc;

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

public:
  virtual ~ToolHandleInfo() {};

  bool isPublic() const {
     return !m_parent;
  }

  bool createIf() const {
     return m_createIf;
  }

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

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

  const std::string toolParentName( const IInterface* parent ) const {
    if (parent) {
      //SmartIF<INamedInterface> pNamed(const_cast<IInterface*>(parent));
      //if (pNamed.isValid()) {
      const INamedInterface* pNamed = dynamic_cast<const INamedInterface*>(parent);
      if (pNamed) {
        return pNamed->name();
      } else {
        return "";
      }
    } else {
      return "ToolSvc";
    }
  }

private:
  const IInterface* m_parent;
  bool m_createIf;
};

template< class T >
class ToolHandle : public ToolHandleInfo, public GaudiHandle<T> {
public:
  //
  // Constructors etc.
  //
  ToolHandle( const IInterface* parent = 0, bool createIf = true )
    : ToolHandleInfo(parent,createIf),
      GaudiHandle<T>( GaudiHandle<T>::getDefaultType(),
              ToolHandleInfo::toolComponentType(parent),
              ToolHandleInfo::toolParentName(parent) ),
      m_pToolSvc( "ToolSvc", GaudiHandleBase::parentName() )
  {}

  ToolHandle( const std::string& toolTypeAndName, const IInterface* parent = 0, bool createIf = true )
    : ToolHandleInfo(parent,createIf),
      GaudiHandle<T>( toolTypeAndName,
              ToolHandleInfo::toolComponentType(parent),
              ToolHandleInfo::toolParentName(parent) ),
      m_pToolSvc( "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();
  }

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

  virtual StatusCode release( T* algTool ) const {
    return m_pToolSvc->releaseTool( algTool );
  }

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