DataOnDemandSvc.h

Go to the documentation of this file.

// $Id: DataOnDemandSvc.h,v 1.10 2008/10/01 14:33:07 marcocle Exp $ 
// ============================================================================
#ifndef GAUDISVC_DATAONDEMANDSVC_H
#define GAUDISVC_DATAONDEMANDSVC_H
// ============================================================================
// Include Files
// ============================================================================
// STD & STL 
// ============================================================================
#include <map>
#include <vector>
// ============================================================================
// GaudiKernel
// ============================================================================
#include "GaudiKernel/Service.h"
#include "GaudiKernel/SvcFactory.h"
#include "GaudiKernel/IIncidentListener.h"
#include "GaudiKernel/ChronoEntity.h"
#include "GaudiKernel/StatEntity.h"
// ============================================================================
// Reflex
// ============================================================================
#include "Reflex/Reflex.h"
// ============================================================================
// Forward declarations
// ============================================================================
class IAlgTool;
class IAlgorithm;
class IAlgManager;
class IIncidentSvc;
class IDataProviderSvc;
// ============================================================================
class DataOnDemandSvc 
  :         public Service
  , virtual public IIncidentListener 
{
public: 
  // ==========================================================================
  // Typedefs
  typedef std::vector<std::string> Setup;
  typedef ROOT::Reflex::Type       ClassH;
  // ==========================================================================
  struct Protection 
  {
    bool& m_bool;
    Protection(bool& b) : m_bool(b) { m_bool = true;  }
    ~Protection()                   { m_bool = false; }
  };
  // ==========================================================================
  struct Node  
  {
    ClassH        clazz     ;
    bool          executing ;
    std::string   name      ;
    unsigned long num       ;
    Node() : clazz() , executing(false) , name (), num(0) {}
    Node(ClassH c, bool e, const std::string& n)
      : clazz(c), executing(e), name(n), num(0) {}
    Node(const Node& c)
      : clazz(c.clazz), executing(c.executing), name(c.name), num(c.num) {}
  };
  // ==========================================================================
  struct Leaf  
  {
    IAlgorithm*   algorithm ;
    bool          executing ;
    std::string   name      ;
    std::string   type      ;
    unsigned long num       ;
    Leaf() : algorithm ( 0 ) , executing (false ) , name() , type() , num ( 0 ) {}
    Leaf(const Leaf& l) 
      : algorithm(l.algorithm), 
        executing(l.executing), name(l.name), type(l.type), num(l.num)  {}
    Leaf(const std::string& t, const std::string& n)
      : algorithm(0), executing(false), name(n), type(t), num(0)  {}
  };
  // ==========================================================================
  struct Timer 
  {
  public:
    // ========================================================================
    Timer  ( ChronoEntity& c ) : m_timer ( c ) { m_timer.start () ; }
    ~Timer ( )        { m_timer.stop  () ; }
    // ========================================================================
  private:
    // ========================================================================
    Timer() ; // no default constructor 
    // ========================================================================
  private:
    // ========================================================================
    ChronoEntity& m_timer ;  // the actual timer 
    // ========================================================================
  } ;
  // ==========================================================================
public:
  // ==========================================================================
  typedef std::map<std::string, Node>  NodeMap;
  typedef std::map<std::string, Leaf>  AlgMap;
  virtual StatusCode initialize();
  virtual StatusCode finalize();
  virtual StatusCode reinitialize();
  virtual StatusCode queryInterface( const InterfaceID& riid, void** ppvInterface );
  virtual void handle(const Incident& incident);
  DataOnDemandSvc( const std::string& name, ISvcLocator* svc );
  virtual ~DataOnDemandSvc();
  // ==========================================================================
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();
  // ==========================================================================
public:
  // ==========================================================================
  void update_1 ( Property& p ) ;
  void update_2 ( Property& p ) ;
  void update_3 ( Property& p ) ;
  // ==========================================================================
protected:
  // ==========================================================================
  StatusCode update() ;
  inline MsgStream& stream () const 
  {
    if ( 0 == m_log ) { m_log = new MsgStream( msgSvc() , name() ) ; }
    return *m_log;
  }
  void dump ( const MSG::Level level , const bool mode = true ) const ;
  // ==========================================================================
private:
  // ==========================================================================
  IIncidentSvc*     m_incSvc;
  IAlgManager*      m_algMgr;
  IDataProviderSvc* m_dataSvc;
  std::string       m_trapType;
  std::string       m_dataSvcName;
  bool              m_partialPath;
  bool              m_dump;
  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  ;
  std::string        m_prefix          ;
  mutable MsgStream* m_log             ;
  // ==========================================================================
  ChronoEntity       m_total           ;
  ulonglong          m_statAlg         ;  
  ulonglong          m_statNode        ;  
  ulonglong          m_stat            ;  
  // ==========================================================================
} ; 
// ============================================================================

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