StandaloneToolHandle.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/

 
 
#ifndef ASG_TOOLS__STANDALONE_TOOL_HANDLE_H
#define ASG_TOOLS__STANDALONE_TOOL_HANDLE_H
 
#include <AsgTools/AsgToolConfig.h>
 
namespace asg
{
 
  template<typename T> class StandaloneToolHandle final
  {
 
  public:
    StandaloneToolHandle () = default;
    StandaloneToolHandle (const std::string& typeAndName)
      : m_config (typeAndName) {}
 

    StatusCode initialize ();

    StatusCode retrieve ();

    T *get () {
      checkIsInitialized (); return m_pointer;}
    const T *get () const {
      checkIsInitialized (); return m_pointer;}
    T *operator -> () {
      checkIsInitialized (); return m_pointer;}
    const T *operator -> () const {
      checkIsInitialized (); return m_pointer;}
    T& operator * () {
      checkIsInitialized (); return *m_pointer;}
    const T& operator * () const {
      checkIsInitialized (); return *m_pointer;}


    const ToolHandle<std::remove_const_t<T>>& getHandle ();
 
 

 
  public:
 
    auto typeAndName () const {
      return m_config.typeAndName();}
    auto name () const {
      return m_config.name();}
    void setTypeAndName (const std::string& typeAndName) {
      checkNotInitialized ();
      m_config.setTypeAndName (typeAndName);}
    template<typename T2>
    StatusCode setProperty (const std::string& name, T2&& value) {
      checkNotInitialized ();
      return m_config.setProperty (name, value);}
    StatusCode createPrivateTool (const std::string& name,
                                  const std::string& toolType) {
      checkNotInitialized ();
      return m_config.createPrivateTool (name, toolType);}
 
 

 
  private:

    T *m_pointer {nullptr};

    ToolHandle<std::remove_const_t<T>> m_toolHandle;

    std::shared_ptr<void> m_cleanup;

    AsgToolConfig m_config;
 

    void checkNotInitialized () const;

    void checkIsInitialized () const;
  };
 
 
 
  template<typename T> StatusCode StandaloneToolHandle<T> ::
  retrieve ()
  {
    if (m_pointer == nullptr)
      return initialize ();
    else
      return StatusCode::SUCCESS;
  }
 
 
 
  template<typename T> StatusCode StandaloneToolHandle<T> ::
  initialize ()
  {
    checkNotInitialized ();
    if (m_config.makeTool (m_toolHandle, m_cleanup, true).isFailure())
      return StatusCode::FAILURE;
    m_pointer = &*m_toolHandle;
    return StatusCode::SUCCESS;
  }
 
 
 
  template<typename T> const ToolHandle<std::remove_const_t<T>>& StandaloneToolHandle<T> ::
  getHandle ()
  {
    checkIsInitialized ();
    return m_toolHandle;
  }
 
 
 
  template<typename T> void StandaloneToolHandle<T> ::
  checkNotInitialized () const
  {
    if (m_pointer)
      throw std::logic_error ("trying to configure StandaloneToolHandle after it was initialized/retrieved");
  }
 
 
 
  template<typename T> void StandaloneToolHandle<T> ::
  checkIsInitialized () const
  {
    if (m_pointer == nullptr)
      throw std::logic_error ("trying to use StandaloneToolHandle that was never initialized/retrieved");
  }
 
 
 
  template <typename T>
  std::ostream& operator << (std::ostream& str, const StandaloneToolHandle<T>& obj)
  {
    return str << "StandaloneToolHandle:" << obj.typeAndName();
  }
}
 
#endif