ReplayOutputStream.cpp

Go to the documentation of this file.

// Include files

// From Gaudi
#include "GaudiKernel/IAlgManager.h"
#include "GaudiKernel/IDataManagerSvc.h"
#include "GaudiKernel/IDataStoreAgent.h"
// local
#include "RecordOutputStream.h"
#include "ReplayOutputStream.h"

#include <algorithm>
#include <functional>
#include <list>

// ----------------------------------------------------------------------------
// Implementation file for class: ReplayOutputStream
//
// 30/08/2013: Marco Clemencic
// ----------------------------------------------------------------------------
DECLARE_ALGORITHM_FACTORY( ReplayOutputStream )

namespace
{

  template <Gaudi::StateMachine::Transition TR>
  class OutStreamTransition
  {
  public:
    typedef ReplayOutputStream::OutStreamsMapType::value_type ItemType;
    OutStreamTransition( MsgStream& msg ) : m_msg( msg ), m_code( StatusCode::SUCCESS, false ) {}

    void operator()( ItemType& item );

    StatusCode result() const { return m_code; }

  private:
    MsgStream& m_msg;
    StatusCode m_code;
  };

  template <>
  void OutStreamTransition<Gaudi::StateMachine::INITIALIZE>::operator()( ItemType& item )
  {
    const StatusCode sc = item.second->sysInitialize();
    if ( sc.isFailure() ) {
      m_msg << MSG::WARNING << "Failed to initialize " << item.first << endmsg;
      m_code = sc;
    }
  }
  template <>
  void OutStreamTransition<Gaudi::StateMachine::START>::operator()( ItemType& item )
  {
    const StatusCode sc = item.second->sysStart();
    if ( sc.isFailure() ) {
      m_msg << MSG::WARNING << "Failed to start " << item.first << endmsg;
      m_code = sc;
    }
  }
  template <>
  void OutStreamTransition<Gaudi::StateMachine::STOP>::operator()( ItemType& item )
  {
    const StatusCode sc = item.second->sysStop();
    if ( sc.isFailure() ) {
      m_msg << MSG::WARNING << "Failed to stop " << item.first << endmsg;
      m_code = sc;
    }
  }
  template <>
  void OutStreamTransition<Gaudi::StateMachine::FINALIZE>::operator()( ItemType& item )
  {
    const StatusCode sc = item.second->sysFinalize();
    if ( sc.isFailure() ) {
      m_msg << MSG::WARNING << "Failed to finalize " << item.first << endmsg;
      m_code = sc;
    }
  }
}

template <Gaudi::StateMachine::Transition TR>
StatusCode ReplayOutputStream::i_outStreamTransition()
{
  OutStreamTransition<TR> trans( msg() );
  std::for_each( m_outputStreams.begin(), m_outputStreams.end(), trans );
  return trans.result();
}

// ============================================================================
// Initialization
// ============================================================================
StatusCode ReplayOutputStream::initialize()
{
  StatusCode sc = GaudiAlgorithm::initialize(); // must be executed first
  if ( sc.isFailure() ) return sc;              // error printed already by GaudiAlgorithm

  if ( msgLevel( MSG::DEBUG ) ) debug() << "==> Initialize" << endmsg;

  m_algMgr = service( "ApplicationMgr" );
  if ( UNLIKELY( !m_algMgr ) ) return Error( "cannot retrieve IAlgManager" );

  m_evtMgr = evtSvc();
  if ( UNLIKELY( !m_evtMgr ) ) return Error( "cannot retrieve IDataManagerSvc " );

  std::for_each( m_outputStreamNames.begin(), m_outputStreamNames.end(), OutStreamAdder( this ) );

  return i_outStreamTransition<Gaudi::StateMachine::INITIALIZE>();
}

StatusCode ReplayOutputStream::start()
{
  StatusCode sc = GaudiAlgorithm::start(); // must be executed first
  if ( sc.isFailure() ) return sc;         // error printed already by GaudiAlgorithm

  if ( msgLevel( MSG::DEBUG ) ) debug() << "==> Start" << endmsg;

  return i_outStreamTransition<Gaudi::StateMachine::START>();
}

namespace
{
  struct OutputStreamsCollector : public IDataStoreAgent {
    std::list<std::string> names;
    bool analyse( IRegistry* pRegistry, int lvl ) override
    {
      if ( lvl > 0 ) names.push_back( pRegistry->name() );
      return true;
    }
  };
}

// ============================================================================
// Main execution
// ============================================================================
StatusCode ReplayOutputStream::execute()
{
  if ( msgLevel( MSG::DEBUG ) ) debug() << "==> Execute" << endmsg;

  OutputStreamsCollector collector;
  m_evtMgr->traverseSubTree( RecordOutputStream::locationRoot(), &collector );

  std::for_each( collector.names.begin(), collector.names.end(), OutStreamTrigger( this ) );

  return StatusCode::SUCCESS;
}

// ============================================================================
// Finalize
// ============================================================================
StatusCode ReplayOutputStream::finalize()
{
  if ( msgLevel( MSG::DEBUG ) ) debug() << "==> Finalize" << endmsg;

  StatusCode sc = i_outStreamTransition<Gaudi::StateMachine::FINALIZE>();

  // release interfaces
  m_outputStreams.clear();
  m_algMgr.reset();
  m_evtMgr.reset();

  StatusCode fsc           = GaudiAlgorithm::finalize(); // must be called after all other actions
  if ( sc.isSuccess() ) sc = fsc;
  return sc;
}

StatusCode ReplayOutputStream::stop()
{
  if ( msgLevel( MSG::DEBUG ) ) debug() << "==> Stop" << endmsg;

  StatusCode sc = i_outStreamTransition<Gaudi::StateMachine::STOP>();

  StatusCode ssc           = GaudiAlgorithm::stop(); // must be called after all other actions
  if ( sc.isSuccess() ) sc = ssc;
  return sc;
}

void ReplayOutputStream::i_addOutputStream( const Gaudi::Utils::TypeNameString& outStream )
{
  // we prepend '/' to the name of the algorithm to simplify the handling in
  // OutputStreamsCollector
  const std::string algId = "/" + outStream.name();
  if ( m_outputStreams.find( algId ) == m_outputStreams.end() ) {
    m_outputStreams[algId] = m_algMgr->algorithm( outStream );
    if ( !m_outputStreams[algId] ) {
      throw GaudiException( name(), "Could not get algorithm " + outStream.name(), StatusCode::FAILURE );
    }
  } else {
    warning() << "OutputStream instance " << outStream.name() << " already added, ignoring " << outStream << endmsg;
  }
}

// ============================================================================