PartitionSwitchAlg.cpp

Go to the documentation of this file.

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

class PartitionSwitchAlg : public extends<Algorithm, IPartitionControl>
{

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

private:
  Gaudi::Property<std::string> m_partName{this, "Partition", "", "option to set the requested partition name"};
  Gaudi::Property<std::string> m_toolType{this, "Tool", "PartitionSwitchTool",
                                          "option to set the tool manipulating the multi-service name"};

  IPartitionControl* m_actor = nullptr;

public:
  using extends::extends;

  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 )... ) : IInterface::Status::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 )... ) : IInterface::Status::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 )