ToolHandle.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ASGTOOLS_TOOLHANDLE_ICC
#define ASGTOOLS_TOOLHANDLE_ICC
 
// System include(s):
#include <stdexcept>
#include <iostream>
 
// Local include(s):
#include "AsgTools/ToolStore.h"
 
template< class T >
ToolHandle< T >::ToolHandle( T* ptool )
: ToolHandleBase(), m_ptool( ptool ) {
   // Set the name in the base class in case we received a valid pointer:
   if( m_ptool ) {
      m_name = m_ptool->name();
   }
}
 
template< class T >
ToolHandle< T >::ToolHandle( const std::string& typeAndName, INamedInterface* parent )
: ToolHandleBase( typeAndName , parent ), m_ptool( 0 ) {
 
}
 
template<typename T> template<typename T2>
ToolHandle<T> ::
ToolHandle (T2 *parent, const std::string& propertyName,
            const std::string& toolName,
            const std::string& propertyTitle)
  : ToolHandle (toolName, parent)
{
  parent->declareProperty (propertyName, *this, propertyTitle);
}
 
template< class T >
PublicToolHandle< T >::PublicToolHandle( const std::string& typeAndName )
: ToolHandle< T >( typeAndName, nullptr ) {
 
}
 
template<typename T> template<typename T2>
PublicToolHandle<T> ::
PublicToolHandle (T2 *parent, const std::string& propertyName,
                  const std::string& toolName,
                  const std::string& propertyTitle)
  : PublicToolHandle (toolName)
{
  parent->declareProperty (propertyName, *this, propertyTitle);
}
 
template< class T >
T& ToolHandle< T >::operator*() {
 
   // Retrieve the tool pointer if necessary:
   if( ! m_ptool ) {
      m_ptool = asg::ToolStore::get< T >( name() );
   }
   // Check if we succeeded:
   if( ! m_ptool ) {
      throw std::runtime_error( "Couldn't find tool with name \"" +
                                name() + "\"" );
   }
 
   // Return a reference to the tool:
   return *m_ptool;
}
 
template< class T >
const T& ToolHandle< T >::operator*() const {
 
   // Retrieve the tool pointer if necessary:
   if( ! m_ptool ) {
      m_ptool = asg::ToolStore::get< T >( name() );
   }
   // Check if we succeeded:
   if( ! m_ptool ) {
      throw std::runtime_error( "Couldn't find tool with name \"" +
                                name() + "\"" );
   }
 
   // Return a reference to the tool:
   return *m_ptool;
}
 
template< class T >
T* ToolHandle<T>::operator->() {
 
   // Retrieve the tool pointer if necessary:
   if( ! m_ptool ) {
      m_ptool = asg::ToolStore::get< T >( name() );
   }
   // Check if we succeeded:
   if( ! m_ptool ) {
      throw std::runtime_error( "Couldn't find tool with name \"" +
                                name() + "\"" );
   }
 
   // Return the (possibly null-)pointer to the tool:
   return m_ptool;
}
 
template< class T >
const T* ToolHandle<T>::operator->() const {
 
   // Retrieve the tool pointer if necessary:
   if( ! m_ptool ) {
      m_ptool = asg::ToolStore::get< T >( name() );
   }
   // Check if we succeeded:
   if( ! m_ptool ) {
      throw std::runtime_error( "Couldn't find tool with name \"" +
                                name() + "\"" );
   }
 
   // Return the (possibly null-)pointer to the tool:
   return m_ptool;
}
 
template< class T >
StatusCode ToolHandle< T >::retrieve() const {
 
   // If we have the tool already, there's nothing to do:
   if( m_ptool ) {
      return StatusCode::SUCCESS;
   }
 
   // Try to retrieve the tool:
   m_ptool = asg::ToolStore::get< T >( name() );
 
   // Check if it succeeded:
   if( m_ptool ) {
      return StatusCode::SUCCESS;
   } else {
      return StatusCode::FAILURE;
   }
}
 
template< class T >
void ToolHandle< T >::disable () noexcept {
  m_ptool = nullptr;
}
 
template< class T >
bool ToolHandle< T >::empty() const {
 
   return ( ( m_ptool == 0 ) && ( name().size() == 0 ) );
}
 
template< class T >
bool ToolHandle< T >::isSet() const {
 
   return ( !( m_ptool == 0 ) );
}
 
template< class T >
std::ostream& operator<<( std::ostream& out,
                          const ToolHandle< T >& handle ) {
 
   out << "ASG ToolHandle with name = \"" << handle.name() << "\", pointer = ";
   const T* ptool = nullptr;
   if (handle.retrieve())
     ptool = handle.operator->();
   out << ptool;
 
   // Return the same stream object:
   return out;
}
 
namespace asg
{
  namespace detail
  {
    StatusCode packStringSingle (const std::string& value,
                 std::string& result);
 
    template<typename T> struct GetStringHelper;
 
    template<typename T> struct GetStringHelper<ToolHandle<T> >
    {
      static StatusCode get (const ToolHandle<T>& value,
                 std::string& result) {
        return packStringSingle (value.typeAndName(), result);
      }
    };
 
    template<typename T> struct GetStringHelper<PublicToolHandle<T> >
      : public GetStringHelper<ToolHandle<T> >
    {
    };
  }
}
 
#endif // ASGTOOLS_TOOLHANDLE_ICC