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"
#include "GaudiKernel/StringKey.h"
// ============================================================================
// Reflex
// ============================================================================
#include "Reflex/Reflex.h"
// ============================================================================
// Forward declarations
// ============================================================================
class IAlgTool;
class IAlgorithm;
class IAlgManager;
class IIncidentSvc;
class IDataProviderSvc;
// ============================================================================
class DataOnDemandSvc: public extends1<Service, 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      ;                              // the actual class
    bool          executing  ;
    std::string   name       ;
    unsigned long num        ;
    bool          dataObject ;                  // trivial object? DataObject?
    // =======================================================================
    Node() 
      : clazz      (       ) 
      , executing  ( false ) 
      , name       (       )
      , num        ( 0     )  
      , dataObject ( false ) 
    {}
    // ========================================================================
    Node ( ClassH             c , 
           bool               e , 
           const std::string& n )
      : clazz     ( c )
      , executing ( e )
      , name      ( n )
      , num       ( 0 )
      , dataObject ( "DataObject" == n ) 
    {}
    //
    Node( const Node& c )
      : clazz      ( c.clazz      )
      , executing  ( c.executing  )
      , name       ( c.name       ) 
      , num        ( c.num        )  
      , dataObject ( c.dataObject ) 
    {}
    // ========================================================================
  };
  // ==========================================================================
  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)  {}
  };
  // ==========================================================================
public:
  // ==========================================================================
  typedef GaudiUtils::HashMap<Gaudi::StringKey, Node>  NodeMap;
  typedef GaudiUtils::HashMap<Gaudi::StringKey, Leaf>  AlgMap;
  virtual StatusCode initialize();
  virtual StatusCode finalize();
  virtual StatusCode reinitialize();
  virtual void handle(const Incident& incident);
  DataOnDemandSvc 
  ( const std::string& name ,                    //       Service instance name
    ISvcLocator*       svc  ) ;                  //  Pointer to service locator
  virtual ~DataOnDemandSvc();                            // 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();
  // ==========================================================================
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() ;
  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 ;
  bool              m_init ;
  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            ;
  // ==========================================================================  
  ChronoEntity       m_timer_nodes     ;
  ChronoEntity       m_timer_algs      ;
  ChronoEntity       m_timer_all       ;
  bool               m_locked_nodes    ;
  bool               m_locked_algs     ;
  bool               m_locked_all      ;
  // ==========================================================================
} ;
// ============================================================================

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