GaudiCommon.h

Go to the documentation of this file.

#ifndef GAUDIALG_GAUDICOMMON_H
#define GAUDIALG_GAUDICOMMON_H 1
// ============================================================================
// Include files
// ============================================================================
// from STL
// ============================================================================
#include <algorithm>
#include <functional>
#include <list>
#include <map>
#include <mutex>
#include <string>
#include <vector>
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiAlg/FixTESPath.h"
#include "GaudiKernel/DataObjectHandle.h"
#include "GaudiKernel/GaudiException.h"
#include "GaudiKernel/HashMap.h"
#include "GaudiKernel/IAlgContextSvc.h"
#include "GaudiKernel/IAlgTool.h"
#include "GaudiKernel/IAlgorithm.h"
#include "GaudiKernel/IChronoStatSvc.h"
#include "GaudiKernel/ICounterSummarySvc.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IMessageSvc.h"
#include "GaudiKernel/IToolSvc.h"
#include "GaudiKernel/IUpdateManagerSvc.h"
#include "GaudiKernel/SmartDataPtr.h"
#include "GaudiKernel/StatEntity.h"
#include "GaudiKernel/StatusCode.h"
#include "GaudiKernel/System.h"

#ifdef __CLING__
#  define WARN_UNUSED
#else
#  define WARN_UNUSED [[nodiscard]]
#endif

// ============================================================================
// forward declarations
// ============================================================================
namespace Gaudi {
  class Algorithm; // GaudiKernel
}
class AlgTool; // GaudiKernel
class ISvcLocator;
namespace Gaudi {
  namespace Utils {
    template <class TYPE>
    struct GetData;
  }
} // namespace Gaudi

namespace GaudiCommon_details {
  constexpr const struct svc_eq_t {
    bool operator()( const std::string& n, const SmartIF<IService>& s ) const { return n == s->name(); };
    bool operator()( const SmartIF<IService>& s, const std::string& n ) const { return s->name() == n; };
    bool operator()( const SmartIF<IService>& s, const SmartIF<IService>& n ) const { return s->name() == n->name(); };
  } svc_eq{};
  constexpr const struct svc_lt_t {
    bool operator()( const std::string& n, const SmartIF<IService>& s ) const { return n < s->name(); };
    bool operator()( const SmartIF<IService>& s, const std::string& n ) const { return s->name() < n; };
    bool operator()( const SmartIF<IService>& s, const SmartIF<IService>& n ) const { return s->name() < n->name(); };
  } svc_lt{};
} // namespace GaudiCommon_details
// ============================================================================
/*  @file GaudiCommon.h
 *
 *  Header file for class : GaudiCommon
 *
 *  @author Chris Jones   Christopher.Rob.Jones@cern.ch
 *  @author Vanya BELYAEV Ivan.Belyaev@itep.ru
 *  @author Rob Lambert Rob.Lambert@cern.ch
 *  @date   2009-08-04
 */
// ============================================================================
// ============================================================================
template <class PBASE>
class GAUDI_API GaudiCommon : public FixTESPath<PBASE> {
protected: // definitions
  using base_class = FixTESPath<PBASE>;

  static const bool IgnoreRootInTES = false;
  static const bool UseRootInTES = true;
  // ==========================================================================
protected: // few actual data types
  // ==========================================================================
  typedef std::map<std::string, StatEntity>                                                    StatisticsOwn;
  typedef std::map<std::string, std::reference_wrapper<Gaudi::Accumulators::PrintableCounter>> Statistics;
  typedef std::map<std::string, unsigned int> Counter;
  typedef std::vector<IAlgTool*> AlgTools;
  typedef std::vector<SmartIF<IService>> Services;

  // ==========================================================================
  // protected members such that they can be used in the derived classes
  SmartIF<ICounterSummarySvc> m_counterSummarySvc;

public:
  // ==========================================================================
  template <class TYPE>
  typename Gaudi::Utils::GetData<TYPE>::return_type get( IDataProviderSvc* svc, const std::string& location,
                                                         const bool useRootInTES = true ) const;
  template <class TYPE>
  typename Gaudi::Utils::GetData<TYPE>::return_type getIfExists( IDataProviderSvc* svc, const std::string& location,
                                                                 const bool useRootInTES = true ) const;
  template <class TYPE>
  bool exist( IDataProviderSvc* svc, const std::string& location, const bool useRootInTES = true ) const;
  template <class TYPE, class TYPE2>
  typename Gaudi::Utils::GetData<TYPE>::return_type getOrCreate( IDataProviderSvc* svc, const std::string& location,
                                                                 const bool useRootInTES = true ) const;
  DataObject* put( IDataProviderSvc* svc, std::unique_ptr<DataObject> object, const std::string& location,
                   const bool useRootInTES = true ) const;
  // [[deprecated( "please pass std::unique_ptr as 2nd argument" )]]
  DataObject* put( IDataProviderSvc* svc, DataObject* object, const std::string& location,
                   const bool useRootInTES = true ) const {
    return put( svc, std::unique_ptr<DataObject>( object ), location, useRootInTES );
  }
  template <class TOOL>
  TOOL* tool( const std::string& type, const std::string& name, const IInterface* parent = 0,
              bool create = true ) const;
  template <class TOOL>
  TOOL* tool( const std::string& type, const IInterface* parent = 0, bool create = true ) const;
  template <class SERVICE>
  SmartIF<SERVICE> svc( const std::string& name, const bool create = true ) const;
  inline IUpdateManagerSvc* updMgrSvc() const;

public:
  WARN_UNUSED
  StatusCode Error( const std::string& msg, const StatusCode st = StatusCode::FAILURE, const size_t mx = 10 ) const;
  WARN_UNUSED
  StatusCode Warning( const std::string& msg, const StatusCode st = StatusCode::FAILURE, const size_t mx = 10 ) const;
  WARN_UNUSED
  StatusCode Info( const std::string& msg, const StatusCode st = StatusCode::SUCCESS, const size_t mx = 10 ) const;
  WARN_UNUSED
  StatusCode Print( const std::string& msg, const StatusCode st = StatusCode::SUCCESS,
                    const MSG::Level lev = MSG::INFO ) const;
  inline void Assert( const bool ok, const std::string& message = "",
                      const StatusCode sc = StatusCode( StatusCode::FAILURE, true ) ) const;
  inline void Assert( const bool ok, const char* message,
                      const StatusCode sc = StatusCode( StatusCode::FAILURE, true ) ) const;
  void Exception( const std::string& msg, const GaudiException& exc,
                  const StatusCode sc = StatusCode( StatusCode::FAILURE, true ) ) const;
  void Exception( const std::string& msg, const std::exception& exc,
                  const StatusCode sc = StatusCode( StatusCode::FAILURE, true ) ) const;
  void Exception( const std::string& msg = "no message",
                  const StatusCode   sc  = StatusCode( StatusCode::FAILURE, true ) ) const;

private:
  inline StatisticsOwn countersOwn() const { return m_countersOwn; }

public:
  //[[deprecated( "see LHCBPS-1758" )]]
  inline StatEntity& counter( const std::string& tag ) const {
    return const_cast<GaudiCommon<PBASE>*>( this )->counter( tag );
  }
  inline StatEntity& counter( const std::string& tag ) {
    std::lock_guard<std::mutex> lock( m_countersOwnMutex );
    // Return referenced StatEntity if it already exists, else create it
    auto p = this->findCounter( tag );
    if ( !p ) {
      auto& counter = m_countersOwn[tag];
      this->declareCounter( tag, counter );
      return counter;
    }
    return m_countersOwn[tag];
  }
  // ==========================================================================
public:
  inline bool typePrint() const { return m_typePrint; }
  inline bool propsPrint() const { return m_propsPrint; }
  inline bool statPrint() const { return m_statPrint; }
  inline bool errorsPrint() const { return m_errorsPrint; }
  // ==========================================================================
public:
  long printStat( const MSG::Level level = MSG::ALWAYS ) const;
  long printErrors( const MSG::Level level = MSG::ALWAYS ) const;
  long printProps( const MSG::Level level = MSG::ALWAYS ) const;
  template <class CallerClass>
  inline void registerCondition( const std::string& condition, StatusCode ( CallerClass::*mf )() = nullptr ) {
    updMgrSvc()->registerCondition( dynamic_cast<CallerClass*>( this ), condition, mf );
  }
  template <class CallerClass, class CondType>
  inline void registerCondition( const std::string& condition, CondType*& condPtrDest,
                                 StatusCode ( CallerClass::*mf )() = NULL ) {
    updMgrSvc()->registerCondition( dynamic_cast<CallerClass*>( this ), condition, mf, condPtrDest );
  }
  template <class CallerClass>
  inline void registerCondition( char* condition, StatusCode ( CallerClass::*mf )() = NULL ) {
    updMgrSvc()->registerCondition( dynamic_cast<CallerClass*>( this ), std::string( condition ), mf );
  }
  template <class CallerClass, class TargetClass>
  inline void registerCondition( TargetClass* condition, StatusCode ( CallerClass::*mf )() = NULL ) {
    updMgrSvc()->registerCondition( dynamic_cast<CallerClass*>( this ), condition, mf );
  }
  inline StatusCode runUpdate() { return updMgrSvc()->update( this ); }

public:
  template <typename U = PBASE, typename = std::enable_if_t<std::is_base_of_v<Gaudi::Algorithm, PBASE>, U>>
  GaudiCommon( const std::string& name, ISvcLocator* pSvcLocator ) : base_class( name, pSvcLocator ) {
    initGaudiCommonConstructor();
  }
  template <typename U = PBASE, typename = std::enable_if_t<std::is_base_of_v<AlgTool, PBASE>, U>>
  GaudiCommon( const std::string& type, const std::string& name, const IInterface* ancestor )
      : base_class( type, name, ancestor ) {
    initGaudiCommonConstructor( this->parent() );
  }

public:
  StatusCode initialize() override;
  StatusCode finalize() override;

private:
  GaudiCommon()                     = delete;
  GaudiCommon( const GaudiCommon& ) = delete;
  GaudiCommon& operator=( const GaudiCommon& ) = delete;

protected:
  StatusCode releaseTool( const IAlgTool* tool ) const;
  StatusCode releaseSvc( const IInterface* svc ) const;

public:
  StatusCode release( const IInterface* interface ) const;

  using PBASE::release;
  // ==========================================================================
public:
  // ==========================================================================
  const Services& services() const { return m_services; } // get all services
  // ==========================================================================
public:
  // ==========================================================================
  inline const std::string& context() const { return m_context; }

private:
  // ==========================================================================
  void addToServiceList( SmartIF<IService> svc ) const;
  void initGaudiCommonConstructor( const IInterface* parent = nullptr );
  // ==========================================================================
private:
  mutable AlgTools m_managedTools;
  mutable Services m_services;
  // ==========================================================================
  mutable Counter m_errors;
  mutable Counter m_warnings;
  mutable Counter m_infos;
  mutable Counter m_exceptions;
  StatisticsOwn m_countersOwn;
  std::mutex m_countersOwnMutex;
  // ==========================================================================
  mutable IUpdateManagerSvc* m_updMgrSvc = nullptr;
  // ==========================================================================
  // Properties
  Gaudi::Property<bool> m_errorsPrint{this, "ErrorsPrint", true,
                                      [this]( auto& ) {
                                        // no action if not yet initialized
                                        if ( this->FSMState() >= Gaudi::StateMachine::INITIALIZED &&
                                             this->errorsPrint() ) {
                                          this->printErrors();
                                        }
                                      },
                                      "print the statistics of errors/warnings/exceptions"};
  Gaudi::Property<bool> m_propsPrint{this, "PropertiesPrint", false,
                                     [this]( auto& ) {
                                       // no action if not yet initialized
                                       if ( this->FSMState() >= Gaudi::StateMachine::INITIALIZED &&
                                            this->propsPrint() ) {
                                         this->printProps( MSG::ALWAYS );
                                       }
                                     },
                                     "print the properties of the component"};
  Gaudi::Property<bool> m_statPrint{this, "StatPrint", true,
                                    [this]( auto& ) {
                                      // no action if not yet initialized
                                      if ( this->FSMState() >= Gaudi::StateMachine::INITIALIZED && this->statPrint() ) {
                                        this->printStat( MSG::ALWAYS );
                                      }
                                    },
                                    "print the table of counters"};
  Gaudi::Property<bool> m_printEmptyCounters{this, "PrintEmptyCounters", false,
                                             "force printing of empty counters, otherwise only printed in DEBUG mode"};
  Gaudi::Property<bool> m_typePrint{this, "TypePrint", true, "add the actual C++ component type into the messages"};

  Gaudi::Property<std::string> m_context{this, "Context", {}, "note: overridden by parent settings"};
  Gaudi::Property<std::string> m_header{this, "StatTableHeader",
                                        " |    Counter                                      |     #     |   "
                                        " sum     | mean/eff^* | rms/err^*  |     min     |     max     |",
                                        "the header row for the output Stat-table"};
  Gaudi::Property<std::string> m_format1{
      this, "RegularRowFormat", " | %|-48.48s|%|50t||%|10d| |%|11.7g| |%|#11.5g| |%|#11.5g| |%|#12.5g| |%|#12.5g| |",
      "the format for regular row in the output Stat-table"};
  Gaudi::Property<std::string> m_format2{
      this, "EfficiencyRowFormat",
      " |*%|-48.48s|%|50t||%|10d| |%|11.5g| |(%|#9.6g| +- %|-#9.6g|)%%|   -------   |   -------   |",
      "The format for \"efficiency\" row in the output Stat-table"};
  Gaudi::Property<bool> m_useEffFormat{this, "UseEfficiencyRowFormat", true,
                                       "use the special format for printout of efficiency counters"};

  Gaudi::Property<std::vector<std::string>> m_counterList{
      this, "CounterList", {".*"}, "RegEx list, of simple integer counters for CounterSummary"};
  Gaudi::Property<std::vector<std::string>> m_statEntityList{
      this, "StatEntityList", {}, "RegEx list, of StatEntity counters for CounterSummary"};
};
// ============================================================================
#include "GaudiAlg/GaudiCommonImp.h"
// ============================================================================

// ============================================================================
// The END
// ============================================================================
#endif // GAUDIALG_GAUDICOMMON_H