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 <map>
#include <string>
#include <vector>
// ============================================================================
// GaudiKernel
// ============================================================================
#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
// ============================================================================
class Algorithm; // GaudiKernel
class AlgTool;   // GaudiKernel
namespace Gaudi
{
  namespace Utils
  {
    template <class TYPE>
    struct GetData;
  }
}

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{};
}
// ============================================================================
/*  @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 PBASE
{
protected: // definitions
  using base_class = PBASE;

  static const bool IgnoreRootInTES = false;
  static const bool UseRootInTES = true;
  // ==========================================================================
protected: // few actual data types
  // ==========================================================================
  typedef std::map<std::string, StatEntity> 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, DataObject* object, const std::string& location,
                   const bool useRootInTES = true ) const;
  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:
  StatusCode Error( const std::string& msg, const StatusCode st = StatusCode::FAILURE, const size_t mx = 10 ) const;
  StatusCode Warning( const std::string& msg, const StatusCode st = StatusCode::FAILURE, const size_t mx = 10 ) const;
  StatusCode Info( const std::string& msg, const StatusCode st = StatusCode::SUCCESS, const size_t mx = 10 ) const;
  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;

public:
  // ==========================================================================
  inline const Statistics& counters() const { return m_counters; }
  inline StatEntity& counter( const std::string& tag ) const { return m_counters[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:
  GaudiCommon( const std::string& name, ISvcLocator* pSvcLocator );
  GaudiCommon( const std::string& type, const std::string& name, const IInterface* parent );

public:
  StatusCode initialize() override
#ifdef __ICC
  {
    return i_gcInitialize();
  }
  StatusCode i_gcInitialize()
#endif
      ;
  StatusCode finalize() override
#ifdef __ICC
  {
    return i_gcFinalize();
  }
  StatusCode i_gcFinalize()
#endif
      ;
protected:
  ~GaudiCommon() override = default;

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
  // ==========================================================================
private:
  // ==========================================================================
  void printErrorHandler( Gaudi::Details::PropertyBase& /* theProp */ ); //      "ErrorPrint"
  void printPropsHandler( Gaudi::Details::PropertyBase& /* theProp */ ); // "PropertiesPrint"
  void printStatHandler( Gaudi::Details::PropertyBase& /* theProp */ ); //       "StatPrint"
  // ==========================================================================
public:
  // ==========================================================================
  inline const std::string& context() const { return m_context; }
  inline const std::string& rootInTES() const { return m_rootInTES; }
  // ==========================================================================
public:
  // ==========================================================================
  const std::string fullTESLocation( const std::string& location, const bool useRootInTES ) const;
  // ==========================================================================
private:
  // ==========================================================================
  void addToServiceList( SmartIF<IService> svc ) const;
  void initGaudiCommonConstructor( const IInterface* parent = 0 );
  // ==========================================================================
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;
  mutable Statistics m_counters;
  // ==========================================================================
  mutable IUpdateManagerSvc* m_updMgrSvc = nullptr;
  // ==========================================================================
  // Properties
  Gaudi::Property<bool> m_errorsPrint{this, "ErrorsPrint", true, "print the statistics of errors/warnings/exceptions"};
  Gaudi::Property<bool> m_propsPrint{this, "PropertiesPrint", false, "print the properties of the component"};
  Gaudi::Property<bool> m_statPrint{this, "StatPrint", true, "print the table of counters"};
  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_rootInTES{this, "RootInTES", {}, "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
// ============================================================================