PartitionSwitchAlg.cpp

Go to the documentation of this file.

//  ====================================================================
//  PartitionSwitchAlg.cpp
//  --------------------------------------------------------------------
//
//  Author    : Markus Frank
//
//  ====================================================================
#include "GaudiKernel/IPartitionControl.h"
#include "GaudiKernel/Algorithm.h"
#include "GaudiKernel/IToolSvc.h"
#include "GaudiKernel/IAlgTool.h"
#include "GaudiKernel/SmartIF.h"

class PartitionSwitchAlg : public extends<Algorithm,
                                          IPartitionControl> {

  using STATUS = StatusCode;
  using CSTR = const std::string&;

private:

  std::string        m_partName;
  std::string        m_toolType;
  IPartitionControl* m_actor = nullptr;

public:

  PartitionSwitchAlg(const std::string& name, ISvcLocator* pSvcLocator)
  : base_class(name, pSvcLocator)
  {
    declareProperty("Partition",  m_partName);
    declareProperty("Tool",       m_toolType="PartitionSwitchTool");
  }
  ~PartitionSwitchAlg() override = default;

  STATUS initialize() override  {
    SmartIF<IAlgTool> tool(m_actor);
    STATUS sc = toolSvc()->retrieveTool(m_toolType,m_actor,this);
    if ( sc.isFailure() ) {
      error() << "Unable to load PartitionSwitchTool "
          << m_toolType << endmsg;
      return sc;
    }
    if ( tool ) toolSvc()->releaseTool(tool);
    IInterface* partititon = nullptr;
    sc = m_actor->get(m_partName, partititon);
    if ( !sc.isSuccess() )  {
      error() << "Cannot access partition \""
          << m_partName << "\"" << endmsg;
    }
    return sc;
  }

  STATUS finalize()  override {
    SmartIF<IAlgTool> tool(m_actor);
    if ( tool ) toolSvc()->releaseTool(tool);
    m_actor = nullptr;
    return STATUS::SUCCESS;
  }

  STATUS execute()  override {
    if ( m_actor )  {
      STATUS sc = m_actor->activate(m_partName);
      if ( !sc.isSuccess() )  {
        error() << "Cannot activate partition \""
            << m_partName << "\"!" << endmsg;
      }
      return sc;
    }
    error() << "The partition control tool \"" << name()
        << "." << m_toolType << "\" cannot be accessed!" << endmsg;
    return STATUS::FAILURE;
  }
private:
  StatusCode log_(StatusCode sc, const std::string& msg)  const {
    error() << msg << " Status=" << sc.getCode() << endmsg;
    return sc;
  }
  template < typename...FArgs, typename...Args>
  StatusCode fwd_( StatusCode (IPartitionControl::*fun)(FArgs...),Args&&... args) {
       return m_actor ? (m_actor->*fun)(std::forward<Args>(args)...) : NO_INTERFACE;
  }
  template < typename...FArgs, typename...Args>
  StatusCode fwd_( StatusCode (IPartitionControl::*fun)(FArgs...) const,Args&&... args) const {
       return m_actor ? (m_actor->*fun)(std::forward<Args>(args)...) : NO_INTERFACE;
  }
public:
  STATUS create(CSTR nam, CSTR typ)  override {
    auto sc = fwd_<CSTR,CSTR>(&IPartitionControl::create,nam,typ);
    return sc.isSuccess() ? sc : log_(sc, "Cannot create partition: "+nam+" of type "+typ);
  }
  STATUS create(CSTR nam, CSTR typ, IInterface*& pPartition)  override {
    auto sc = fwd_<CSTR,CSTR,IInterface*&>(&IPartitionControl::create,nam,typ,pPartition);
    return sc.isSuccess() ? sc : log_(sc, "Cannot create partition: "+nam+" of type "+typ);
  }
  STATUS drop(CSTR nam)  override {
    auto sc = fwd_<CSTR>(&IPartitionControl::drop,nam);
    return  sc.isSuccess() ? sc : log_(sc, "Cannot drop partition: "+nam);
  }
  STATUS drop(IInterface* pPartition)  override {
    auto sc = fwd_<IInterface*>(&IPartitionControl::drop,pPartition);
    return sc.isSuccess() ? sc : log_(sc, "Cannot drop partition by Interface.");
  }
  STATUS activate(CSTR nam)  override {
    auto sc = fwd_<CSTR>(&IPartitionControl::activate,nam);
    return sc.isSuccess() ? sc : log_(sc, "Cannot activate partition: "+nam);
  }
  STATUS activate(IInterface* pPartition)  override {
    auto sc = fwd_<IInterface*>(&IPartitionControl::activate, pPartition);
    return sc.isSuccess() ? sc : log_(sc, "Cannot activate partition by Interface.");
  }
  STATUS get(CSTR nam, IInterface*& pPartition) const override {
    auto sc = fwd_<CSTR,IInterface*&>(&IPartitionControl::get, nam, pPartition);
    return sc.isSuccess() ? sc : log_(sc, "Cannot get partition "+nam);
  }
  STATUS activePartition(std::string& nam, IInterface*& pPartition) const override {
    auto sc = fwd_<std::string&,IInterface*&>(&IPartitionControl::activePartition,nam,pPartition);
    return sc.isSuccess() ? sc : log_(sc, "Cannot determine active partition.");
  }
};

DECLARE_COMPONENT(PartitionSwitchAlg)