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/ChronoEntity.h"
#include "GaudiKernel/IDODAlgMapper.h"
#include "GaudiKernel/IDODNodeMapper.h"
#include "GaudiKernel/IIncidentListener.h"
#include "GaudiKernel/Service.h"
#include "GaudiKernel/StatEntity.h"
#include "GaudiKernel/StringKey.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;
  using extends::extends;
  // ==========================================================================
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 );
  // ==========================================================================
protected:
  // ==========================================================================
  StatusCode update();
  void dump( const MSG::Level level, const bool mode = true ) const;
  // ==========================================================================
private:
  // ==========================================================================
  void force_update( Gaudi::Details::PropertyBase& p )
  {
    verbose() << "updated property " << p.name() << ", forcing update" << endmsg;
    m_updateRequired = true;
  };
  void deprecated_property( Gaudi::Details::PropertyBase& p )
  {
    warning() << p.name() << " " << p.documentation() << endmsg;
    force_update( p );
  };

  // ==========================================================================
  SmartIF<IIncidentSvc> m_incSvc = nullptr;
  SmartIF<IAlgManager> m_algMgr = nullptr;
  SmartIF<IDataProviderSvc> m_dataSvc = nullptr;
  SmartIF<IToolSvc> m_toolSvc;
  AlgMap m_algs;
  NodeMap m_nodes;

  bool m_updateRequired = true;
  // ==========================================================================
  ChronoEntity       m_total;
  unsigned long long m_statAlg  = 0;
  unsigned long long m_statNode = 0;
  unsigned long long 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<IDODNodeMapper*> m_nodeMappers;
  std::vector<IDODAlgMapper*>  m_algMappers;
  // ==========================================================================
  // Properties
  Gaudi::Property<std::string> m_trapType{this, "IncidentName", "DataFault", "the type of handled Incident"};
  Gaudi::Property<std::string> m_dataSvcName{this, "DataSvc", "EventDataSvc", "DataSvc name"};

  Gaudi::Property<bool> m_partialPath{this, "UsePreceedingPath", true, "allow creation of partial leaves"};
  Gaudi::Property<bool> m_dump{
      this, "Dump", false,
      [this]( auto& ) {
        if ( m_dump && FSMState() >= Gaudi::StateMachine::INITIALIZED ) {
          dump( MSG::ALWAYS );
        }
      },
      "dump configuration and stastics, if set to True after initialize it triggers a dump immediately"};
  Gaudi::Property<bool> m_init{this, "PreInitialize", false, "(pre)initialize all algorithms"};
  Gaudi::Property<bool> m_allowInitFailure{
      this, "AllowPreInitializeFailure", false,
      "allow (pre)initialization of algorithms to fail without stopping the application"};

  Gaudi::Property<Setup> m_algMapping{
      this, "Algorithms", {}, &DataOnDemandSvc::deprecated_property, "[[deprecated]] use AlgMap"};
  Gaudi::Property<Setup> m_nodeMapping{
      this, "Nodes", {}, &DataOnDemandSvc::deprecated_property, "[[deprecated]] use NodeMap"};

  typedef std::map<std::string, std::string> Map;
  Gaudi::Property<Map> m_algMap{this, "AlgMap", {}, &DataOnDemandSvc::force_update, "mapping {'data': 'algorithm'}"};
  Gaudi::Property<Map> m_nodeMap{this, "NodeMap", {}, &DataOnDemandSvc::force_update, "mapping {'data': 'type'}"};

  Gaudi::Property<std::string> m_prefix{this, "Prefix", "/Event/"};

  Gaudi::Property<std::vector<std::string>> m_nodeMapTools{
      this, "NodeMappingTools", {}, "list of tools of type IDODNodeMapper"};
  Gaudi::Property<std::vector<std::string>> m_algMapTools{
      this, "AlgMappingTools", {}, "list of tools of type IDODAlgMapper"};
};
// ============================================================================

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