DataOnDemandSvc.h

Go to the documentation of this file.

#ifndef GAUDISVC_DATAONDEMANDSVC_H
#define GAUDISVC_DATAONDEMANDSVC_H
// ============================================================================
// Include Files
// ============================================================================
// STD & STL
// ============================================================================
#include <map>
#include <vector>
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/Service.h"
#include "GaudiKernel/IIncidentListener.h"
#include "GaudiKernel/ChronoEntity.h"
#include "GaudiKernel/StatEntity.h"
#include "GaudiKernel/StringKey.h"
#include "GaudiKernel/IDODAlgMapper.h"
#include "GaudiKernel/IDODNodeMapper.h"
// ============================================================================
// ROOT TClass
// ============================================================================
#include "TClass.h"
// ============================================================================
// Forward declarations
// ============================================================================
class IAlgTool;
class IAlgorithm;
class IAlgManager;
class IIncidentSvc;
class IDataProviderSvc;
class IToolSvc;
// ============================================================================
class DataOnDemandSvc: public extends<Service,
                                      IIncidentListener>
{
public:
  // ==========================================================================
  // Typedefs
  typedef std::vector<std::string> Setup;
  typedef TClass*                  ClassH;
  // ==========================================================================
  struct Protection
  {
    bool& m_bool;
    Protection(bool& b) : m_bool(b) { m_bool = true;  }
    ~Protection()                   { m_bool = false; }
  };
  // ==========================================================================
  struct Node
  {
    // ========================================================================
    ClassH        clazz      ;                              // the actual class
    std::string   name       ;
    unsigned long num        = 0;
    bool          executing  = false;
    bool          dataObject = false ;          // trivial object? DataObject?
    // =======================================================================
    Node() = default;
    // ========================================================================
    Node ( ClassH      c ,
           bool        e ,
           std::string n )
      : clazz     ( c )
      , name      ( std::move(n) )
      , executing ( e )
      , dataObject ( "DataObject" == name )
    {}
    //
    Node( const Node& c )
      : clazz      ( c.clazz      )
      , name       ( c.name       )
      , num        ( c.num        )
      , executing  ( c.executing  )
      , dataObject ( c.dataObject )
    {}
    // ========================================================================
  };
  // ==========================================================================
  struct Leaf
  {
    IAlgorithm*   algorithm = nullptr;
    std::string   name      ;
    std::string   type      ;
    unsigned long num       = 0;
    bool          executing = false;
    Leaf() = default;
    Leaf(const Leaf& l) = default;
    Leaf(std::string t, std::string n)
      : name(std::move(n)), type(std::move(t))  {}
  };
  // ==========================================================================
public:
  // ==========================================================================
  typedef GaudiUtils::HashMap<Gaudi::StringKey, Node>  NodeMap;
  typedef GaudiUtils::HashMap<Gaudi::StringKey, Leaf>  AlgMap;
  StatusCode initialize() override;
  StatusCode finalize() override;
  StatusCode reinitialize() override;
  void handle(const Incident& incident) override;
  DataOnDemandSvc
  ( const std::string& name ,                    //       Service instance name
    ISvcLocator*       svc  ) ;                  //  Pointer to service locator
  ~DataOnDemandSvc() override = default;         // Standard destructor
  // ==========================================================================
protected:
  // ==========================================================================
   StatusCode configureHandler(Leaf& leaf);
  // ==========================================================================
  StatusCode execHandler(const std::string& tag, Leaf& leaf);
  // ==========================================================================
  StatusCode execHandler(const std::string& tag, Node& node);
  // ==========================================================================
  StatusCode setupNodeHandlers();
  // ==========================================================================
  StatusCode setupAlgHandlers();
  // ==========================================================================
  StatusCode setup();
  void i_setNodeHandler(const std::string &name, const std::string &type);
  StatusCode i_setAlgHandler(const std::string &name, const Gaudi::Utils::TypeNameString &alg);
  // ==========================================================================
public:
  // ==========================================================================
  void update_1 ( Property& p ) ;
  void update_2 ( Property& p ) ;
  void update_3 ( Property& p ) ;
  void update_dump ( Property& /* p */ ) ;// update handler for 'Dump' property
  // ==========================================================================
protected:
  // ==========================================================================
  StatusCode update() ;
  void dump ( const MSG::Level level , const bool mode = true ) const ;
  // ==========================================================================
private:
  // ==========================================================================
  SmartIF<IIncidentSvc>     m_incSvc = nullptr;
  SmartIF<IAlgManager>      m_algMgr = nullptr;
  SmartIF<IDataProviderSvc> m_dataSvc = nullptr;
  SmartIF<IToolSvc>         m_toolSvc;
  std::string       m_trapType = "DataFault";
  std::string       m_dataSvcName = "EventDataSvc" ;
  bool              m_partialPath = true;
  bool              m_dump  = false;
  bool              m_init  = false;
  bool              m_allowInitFailure = false;
  Setup             m_algMapping;
  Setup             m_nodeMapping;
  AlgMap            m_algs;
  NodeMap           m_nodes;
  //
  typedef std::map<std::string,std::string> Map ;
  Map                m_algMap          ; // { 'data' : 'algorithm' }
  Map                m_nodeMap         ; // { 'data' : 'type' }
  bool               m_updateRequired = true ;
  std::string        m_prefix         = "/Event/"  ;
  // ==========================================================================
  ChronoEntity       m_total           ;
  ulonglong          m_statAlg        = 0;
  ulonglong          m_statNode       = 0;
  ulonglong          m_stat           = 0;
  // ==========================================================================
  ChronoEntity       m_timer_nodes     ;
  ChronoEntity       m_timer_algs      ;
  ChronoEntity       m_timer_all       ;
  bool               m_locked_nodes   = false ;
  bool               m_locked_algs    = false ;
  bool               m_locked_all     = false ;
  // ==========================================================================
  std::vector<std::string> m_nodeMapTools;
  std::vector<IDODNodeMapper *> m_nodeMappers;
  std::vector<std::string> m_algMapTools;
  std::vector<IDODAlgMapper *> m_algMappers;
};
// ============================================================================

// ============================================================================
// The END
// ============================================================================
#endif // GAUDISVC_DATAONDEMANDSVC_H
// ============================================================================