GaudiCommon.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2021 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#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"
 
// ============================================================================
// 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()( std::string_view n, const SmartIF<IService>& s ) const { return n == s->name(); };
    bool operator()( const SmartIF<IService>& s, std::string_view 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()( std::string_view n, const SmartIF<IService>& s ) const { return n < s->name(); };
    bool operator()( const SmartIF<IService>& s, std::string_view 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, std::less<>> StatisticsOwn;
  typedef std::map<std::string, std::reference_wrapper<Gaudi::Accumulators::PrintableCounter>, std::less<>> Statistics;
  typedef std::map<std::string, unsigned int, std::less<>> 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, std::string_view location,
                                                         const bool useRootInTES = true ) const;
  template <class TYPE>
  typename Gaudi::Utils::GetData<TYPE>::return_type getIfExists( IDataProviderSvc* svc, std::string_view location,
                                                                 const bool useRootInTES = true ) const;
  template <class TYPE>
  bool exist( IDataProviderSvc* svc, std::string_view location, const bool useRootInTES = true ) const;
  template <class TYPE, class TYPE2>
  typename Gaudi::Utils::GetData<TYPE>::return_type getOrCreate( IDataProviderSvc* svc, std::string_view location,
                                                                 const bool useRootInTES = true ) const;
  DataObject* put( IDataProviderSvc* svc, std::unique_ptr<DataObject> object, std::string_view location,
                   const bool useRootInTES = true ) const;
  // [[deprecated( "please pass std::unique_ptr as 2nd argument" )]]
  DataObject* put( IDataProviderSvc* svc, DataObject* object, std::string_view location,
                   const bool useRootInTES = true ) const {
    return put( svc, std::unique_ptr<DataObject>( object ), location, useRootInTES );
  }
  template <class TOOL>
  TOOL* tool( std::string_view type, std::string_view name, const IInterface* parent = 0, bool create = true ) const;
  template <class TOOL>
  TOOL* tool( std::string_view type, const IInterface* parent = 0, bool create = true ) const;
  template <class SERVICE>
  SmartIF<SERVICE> svc( std::string_view name, const bool create = true ) const;
  IUpdateManagerSvc* updMgrSvc() const;
 
public:
  StatusCode Error( std::string_view msg, const StatusCode st = StatusCode::FAILURE, const size_t mx = 10 ) const;
  StatusCode Warning( std::string_view msg, const StatusCode st = StatusCode::FAILURE, const size_t mx = 10 ) const;
  StatusCode Info( std::string_view msg, const StatusCode st = StatusCode::SUCCESS, const size_t mx = 10 ) const;
  StatusCode Print( std::string_view msg, const StatusCode st = StatusCode::SUCCESS,
                    const MSG::Level lev = MSG::INFO ) const;
  void Assert( const bool ok, std::string_view message = "", const StatusCode sc = StatusCode::FAILURE ) const;
  void Exception( std::string_view msg, const GaudiException& exc, const StatusCode sc = StatusCode::FAILURE ) const;
  void Exception( std::string_view msg, const std::exception& exc, const StatusCode sc = StatusCode::FAILURE ) const;
  void Exception( std::string_view msg = "no message", const StatusCode sc = StatusCode::FAILURE ) const;
 
private:
  StatisticsOwn countersOwn() const { return m_countersOwn; }
 
public:
  //[[deprecated( "see LHCBPS-1758" )]], on top no garantee about thread safety
  StatEntity& counter( std::string_view tag ) const { return const_cast<GaudiCommon<PBASE>*>( this )->counter( tag ); }
  StatEntity& counter( std::string_view tag ) {
    auto lock = std::scoped_lock{ m_countersOwnMutex };
    // Return referenced StatEntity if it already exists, else create it
    auto p = m_countersOwn.find( tag );
    if ( p == m_countersOwn.end() ) {
      auto [iter, b] = m_countersOwn.try_emplace( std::string{ tag } );
      assert( b );
      this->serviceLocator()->monitoringHub().registerEntity( this->name(), iter->first, StatEntity::typeString,
                                                              iter->second );
      p = iter;
    }
    return p->second;
  }
  // ==========================================================================
public:
  long printErrors( const MSG::Level level = MSG::ALWAYS ) const;
  long printProps( const MSG::Level level = MSG::ALWAYS ) const;
  template <class CallerClass>
  void registerCondition( const std::string& condition, StatusCode ( CallerClass::*mf )() = nullptr ) {
    updMgrSvc()->registerCondition( dynamic_cast<CallerClass*>( this ), condition, mf );
  }
  template <class CallerClass, class CondType>
  void registerCondition( const std::string& condition, CondType*& condPtrDest,
                          StatusCode ( CallerClass::*mf )() = NULL ) {
    updMgrSvc()->registerCondition( dynamic_cast<CallerClass*>( this ), condition, mf, condPtrDest );
  }
  template <class CallerClass>
  void registerCondition( char* condition, StatusCode ( CallerClass::*mf )() = NULL ) {
    updMgrSvc()->registerCondition( dynamic_cast<CallerClass*>( this ), std::string( condition ), mf );
  }
  template <class CallerClass, class TargetClass>
  void registerCondition( TargetClass* condition, StatusCode ( CallerClass::*mf )() = NULL ) {
    updMgrSvc()->registerCondition( dynamic_cast<CallerClass*>( this ), condition, mf );
  }
  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( std::string name, ISvcLocator* pSvcLocator ) : base_class( std::move( name ), pSvcLocator ) {
    initGaudiCommonConstructor();
  }
  template <typename U = PBASE, typename = std::enable_if_t<std::is_base_of_v<AlgTool, PBASE>, U>>
  GaudiCommon( std::string type, std::string name, const IInterface* ancestor )
      : base_class( std::move( type ), std::move( name ), ancestor ) {
    initGaudiCommonConstructor( this->parent() );
  }
 
public:
  StatusCode initialize() override;
  StatusCode finalize() override;
 
  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:
  // ==========================================================================
  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;
  // ==========================================================================
  static auto increment( Counter& c, std::string_view which ) {
    auto i = c.find( which );
    return i != c.end() ? ++( i->second ) : c.emplace( which, 1 ).first->second;
  }
  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;
 
protected:
  // ==========================================================================
  // Properties
  Gaudi::Property<bool> m_errorsPrint{ this, "ErrorsPrint", true,
                                       [this]( auto& ) {
                                         // no action if not yet initialized
                                         if ( this->FSMState() >= Gaudi::StateMachine::INITIALIZED &&
                                              this->m_errorsPrint.value() ) {
                                           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->m_propsPrint.value() ) {
                                          this->printProps( MSG::ALWAYS );
                                        }
                                      },
                                      "print the properties of the component" };
  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::vector<std::string>> m_counterList{
      this, "CounterList", { ".*" }, "RegEx list, of simple integer counters for CounterSummary" };
};
// ============================================================================
#include "GaudiAlg/GaudiCommonImp.h"
// ============================================================================
 
// ============================================================================
// The END
// ============================================================================
#endif // GAUDIALG_GAUDICOMMON_H