AsgToolConfig.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
 
 
 
#ifndef ASG_TOOLS_ASG_TOOL_CONFIG_H
#define ASG_TOOLS_ASG_TOOL_CONFIG_H
 
#include <AsgTools/AsgComponentConfig.h>
#include <AsgTools/ToolHandle.h>
 
namespace asg
{
  class AsgTool;
 
 
  class AsgToolConfig : public asg::AsgComponentConfig
  {
    //
    // public interface
    //
 
  public:
    AsgToolConfig () = default;
 
 
  public:
    explicit AsgToolConfig (const std::string& val_typeAndName);
 
 
  public:
    explicit AsgToolConfig (const AsgComponentConfig& val_config);
 
 
  public:
    template<typename T> ::StatusCode
    makeTool (ToolHandle<T>& toolHandle,
              std::shared_ptr<void>& cleanup,
              bool allowNestedName = false) const;
 
 
  public:
    template<typename T> ::StatusCode
    makePrivateTool (ToolHandle<T>& toolHandle) const;
 
 
 
    //
    // private interface
    //
  };
 
 
 
  //
  // template methods
  //
 
#ifdef XAOD_STANDALONE
 
  template<typename T> ::StatusCode AsgToolConfig ::
  makeTool (ToolHandle<T>& toolHandle,
            std::shared_ptr<void>& cleanup,
            bool allowNestedName) const
  {
    using namespace msgComponentConfig;
 
    std::string prefix = toolHandle.parentName() + ".";
 
    std::unique_ptr<T> tool;
    ANA_CHECK (makeComponentExpert (tool, "new %1% (\"%2%\")", allowNestedName, prefix));
    ANA_CHECK (tool->initialize());
 
    std::shared_ptr<T> mycleanup (tool.release());
    toolHandle = mycleanup.get();
    cleanup = mycleanup;
 
    ANA_MSG_DEBUG ("Created component of type " << type());
    return StatusCode::SUCCESS;
  }
 
  template<typename T> ::StatusCode AsgToolConfig ::
  makePrivateTool (ToolHandle<T>& toolHandle) const
  {
    using namespace msgComponentConfig;
 
    INamedInterface *parentNamed = toolHandle.parent();
    if (parentNamed == nullptr)
    {
      ANA_MSG_ERROR ("need to pass private ToolHandle into makePrivateTool");
      return StatusCode::FAILURE;
    }
    AsgComponent *parentComponent = dynamic_cast<AsgComponent*>(parentNamed);
    if (parentComponent == nullptr)
    {
      ANA_MSG_ERROR ("parent \"" << parentNamed->name() << "\" for makePrivateTool() does not inherit from AsgComponent");
      return StatusCode::FAILURE;
    }
 
    std::shared_ptr<void> cleanup;
    if (makeTool (toolHandle, cleanup).isFailure())
      return StatusCode::FAILURE;
    parentComponent->addCleanup (cleanup);
    return StatusCode::SUCCESS;
  }
 
#else
 
  template<typename T> ::StatusCode AsgToolConfig ::
  makeTool (ToolHandle<T>& toolHandle,
            std::shared_ptr<void>& /*cleanup*/,
            bool allowNestedName) const
  {
    using namespace msgComponentConfig;
 
    std::string prefix = toolHandle.parentName() + ".";
 
    ANA_CHECK (configureComponentExpert (prefix, allowNestedName));
    toolHandle.setTypeAndName (type() + "/" + name());
    ANA_CHECK (toolHandle.retrieve());
 
    ANA_MSG_DEBUG ("Created component of type " << type());
    return StatusCode::SUCCESS;
  }
 
  template<typename T> ::StatusCode AsgToolConfig ::
  makePrivateTool (ToolHandle<T>& toolHandle) const
  {
    using namespace msgComponentConfig;
 
    // This is safe, because the `makeTool` function in athena does
    // not use the cleanup argument.
    std::shared_ptr<void> cleanup;
    return makeTool (toolHandle, cleanup);
  }
 
#endif
 
}
 
#endif