IAlgExecStateSvc.h

Go to the documentation of this file.

#ifndef GAUDIKERNEL_IALGEXECSTATESVC_H
#define GAUDIKERNEL_IALGEXECSTATESVC_H 1

#include "GaudiKernel/IAlgorithm.h"
#include "GaudiKernel/IInterface.h"
#include "GaudiKernel/StatusCode.h"
#include "GaudiKernel/StringKey.h"
#include <map>
#include <sstream>
#include <string>

class EventContext;

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

class AlgExecState {
public:
  enum State { None = 0, Executing = 1, Done = 2 };

  bool              filterPassed() const { return m_filterPassed; }
  State             state() const { return m_state; }
  const StatusCode& execStatus() const { return m_execStatus; }

  void setFilterPassed( bool f = true ) { m_filterPassed = f; }
  void setState( State s ) { m_state = s; }
  void setState( State s, const StatusCode& sc ) {
    m_state      = s;
    m_execStatus = sc;
  }
  void setExecStatus( const StatusCode& sc = StatusCode::SUCCESS ) { m_execStatus = sc; }
  void reset() { *this = AlgExecState{}; }

private:
  bool       m_filterPassed{true};
  State      m_state{State::None};
  StatusCode m_execStatus{StatusCode( StatusCode::FAILURE, true )};
};

inline std::ostream& operator<<( std::ostream& ost, const AlgExecState& s ) {
  ost << "e: ";
  switch ( s.state() ) {
  case AlgExecState::State::None:
    return ost << "n";
  case AlgExecState::State::Executing:
    return ost << "e";
  default:
    return ost << "d f: " << s.filterPassed() << " sc: " << s.execStatus();
  }
}

namespace EventStatus {
  enum Status { Invalid = 0, Success = 1, AlgFail = 2, AlgStall = 3, Other = 4 };
  inline std::ostream& operator<<( std::ostream& os, Status s ) {
    static constexpr std::array<const char*, 5> label{"Invalid", "Success", "AlgFail", "AlgStall", "Other"};
    return os << label.at( s );
  }
} // namespace EventStatus

class GAUDI_API IAlgExecStateSvc : virtual public IInterface {
public:
  DeclareInterfaceID( IAlgExecStateSvc, 1, 0 );

  typedef std::map<Gaudi::StringKey, AlgExecState> AlgStateMap_t;

  // get the Algorithm Execution State for a give Algorithm and EventContext
  virtual const AlgExecState& algExecState( const Gaudi::StringKey& algName, const EventContext& ctx ) const = 0;
  const AlgExecState&         algExecState( IAlgorithm* iAlg, const EventContext& ctx ) const {
    return algExecState( iAlg->nameKey(), ctx );
  }
  virtual AlgExecState& algExecState( IAlgorithm* iAlg, const EventContext& ctx ) = 0;

  // get all the Algorithm Execution States for a given EventContext
  virtual const AlgStateMap_t& algExecStates( const EventContext& ctx ) const = 0;

  virtual void reset( const EventContext& ctx ) = 0;

  virtual void addAlg( const Gaudi::StringKey& algName ) = 0;
  void         addAlg( IAlgorithm* iAlg ) { addAlg( iAlg->nameKey() ); }

  virtual const EventStatus::Status& eventStatus( const EventContext& ctx ) const = 0;

  virtual void setEventStatus( const EventStatus::Status& sc, const EventContext& ctx ) = 0;

  virtual void updateEventStatus( const bool& b, const EventContext& ctx ) = 0;

  virtual unsigned int algErrorCount( const IAlgorithm* iAlg ) const = 0;
  virtual void         resetErrorCount( const IAlgorithm* iAlg )     = 0;
  virtual unsigned int incrementErrorCount( const IAlgorithm* iAlg ) = 0;

  virtual void dump( std::ostringstream& ost, const EventContext& ctx ) const = 0;
};

#endif