GaudiCommon.h

Go to the documentation of this file.

#ifndef GAUDIALG_GAUDICOMMON_H
#define GAUDIALG_GAUDICOMMON_H 1
// ============================================================================
// Include files
// ============================================================================
// from STL
// ============================================================================
#include <string>
#include <vector>
#include <map>
#include <algorithm>
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/StatusCode.h"
#include "GaudiKernel/IMessageSvc.h"
#include "GaudiKernel/IToolSvc.h"
#include "GaudiKernel/IAlgTool.h"
#include "GaudiKernel/IAlgContextSvc.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/IAlgorithm.h"
#include "GaudiKernel/SmartDataPtr.h"
#include "GaudiKernel/System.h"
#include "GaudiKernel/GaudiException.h"
#include "GaudiKernel/IChronoStatSvc.h"
#include "GaudiKernel/StatEntity.h"
#include "GaudiKernel/ICounterSummarySvc.h"
#include "GaudiKernel/IUpdateManagerSvc.h"
#include "GaudiKernel/HashMap.h"
#include "GaudiKernel/CommonMessaging.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 CommonMessaging<PBASE>
{
protected: // definitions
  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 ;
  std::vector<std::string> m_counterList = std::vector<std::string>(1,".*");
  //list of stat entities to write. Set by property StatEntityList. This can be a regular expression.
  std::vector<std::string> m_statEntityList = std::vector<std::string>(0);
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:
  void resetMsgStream() const;
  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  ; }
  // ==========================================================================
private:
  // ==========================================================================
  void msgLevelHandler ( Property& theProp );
  // ==========================================================================
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 AlgTools& tools    () const { return m_tools    ; }    // get all tools
  const Services& services () const { return m_services ; } // get all services
  // ==========================================================================
private:
  // ==========================================================================
  void printErrorHandler ( Property& /* theProp */ ) ;     //      "ErrorPrint"
  void printPropsHandler ( Property& /* theProp */ ) ;     // "PropertiesPrint"
  void printStatHandler  ( Property& /* theProp */ ) ;     //       "StatPrint"
  // ==========================================================================
public:
  // ==========================================================================
  inline const std::string & context() const { return m_context; }
  inline const std::string & rootInTES() const { return m_rootInTES; }
  inline double globalTimeOffset() const { return m_globalTimeOffset; }
  // ==========================================================================
public:
  // ==========================================================================
  const std::string     fullTESLocation
  ( const std::string & location     ,
    const bool          useRootInTES ) const ;
  // ==========================================================================
private:
  // ==========================================================================
  void addToToolList    ( IAlgTool * tool ) const;
  void addToServiceList ( SmartIF<IService> svc ) const;
  void initGaudiCommonConstructor( const IInterface * parent = 0 );
  // ==========================================================================
private:
  MSG::Level  m_msgLevel    = MSG::NIL;
private:
  mutable std::unique_ptr<MsgStream> m_msgStream    ;
  mutable AlgTools   m_tools       ;
  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;
  // ==========================================================================
  bool        m_typePrint = true    ;
  bool        m_propsPrint = false   ;
  bool        m_statPrint = true    ;
  bool        m_errorsPrint = true  ;
  // ==========================================================================
  std::string m_context;
  std::string m_rootInTES;
  std::string m_rootOnTES;
  double m_globalTimeOffset = 0;
  // ==========================================================================
  // the header row
  std::string    m_header  ; 
  // format for regular statistical printout rows
  std::string    m_format1 ; 
  // format for "efficiency" statistical printout rows
  std::string    m_format2 ; 
  // flag to use the special "efficiency" format
  bool           m_useEffFormat ; 
} ;
// ============================================================================
#include "GaudiAlg/GaudiCommonImp.h"
// ============================================================================

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