In This Package:

UpdateManagerSvc.h

Go to the documentation of this file.

// $Id: UpdateManagerSvc.h,v 1.13 2009/01/16 12:03:46 ocallot Exp $
#ifndef UPDATEMANAGERSVC_H
#define UPDATEMANAGERSVC_H 1

// Include files
#include "GaudiKernel/Service.h"
#include "GaudiKernel/Time.h"
#include "GaudiKernel/ClassID.h"
#include "GaudiKernel/IOpaqueAddress.h"
#include "GaudiKernel/IIncidentListener.h"
#include "GaudiKernel/MsgStream.h"

#include "GaudiKernel/IUpdateManagerSvc.h"
#include "GaudiKernel/UpdateManagerException.h"

#include "GaudiKernel/Map.h"

#include "GaudiKernel/HashMap.h"

#include <string>
#include <map>
#include <exception>
#include <algorithm>

#ifndef WIN32
#include <pthread.h>
#endif

// Forward declarations
template <class TYPE> class SvcFactory;
class IIncidentSvc;
class IEventProcessor;
class Condition;

class UpdateManagerSvc: public virtual Service,
                        public virtual IUpdateManagerSvc,
                        public virtual IIncidentListener {
public:
  UpdateManagerSvc(const std::string& name, ISvcLocator* svcloc);

  virtual ~UpdateManagerSvc( ); 

  virtual StatusCode queryInterface(const InterfaceID& riid, void** ppvUnknown);

  virtual StatusCode initialize();

  virtual StatusCode finalize();

  virtual IDataProviderSvc *dataProvider() const;
  virtual IDetDataSvc *detDataSvc() const;

  virtual StatusCode newEvent();
  virtual StatusCode newEvent(const Gaudi::Time &evtTime);

  //virtual StatusCode runAll() const;

  virtual bool getValidity(const std::string path, Gaudi::Time& since, Gaudi::Time &until, bool path_to_db = false);
  virtual void setValidity(const std::string path, const Gaudi::Time& since, const Gaudi::Time &until, bool path_to_db = false);

  virtual void dump();

  virtual void acquireLock();
  virtual void releaseLock();

  virtual void purge();

  // ---- Implement IIncidentListener interface ----
  virtual void handle(const Incident &inc);

protected:

  //  virtual StatusCode i_registerCondition(const std::string &condition, BaseObjectMemberFunction *mf);

  virtual void i_registerCondition(const std::string &condition, BaseObjectMemberFunction *mf,
                                         BasePtrSetter *ptr_dest = NULL);

  virtual void i_registerCondition(void *obj, BaseObjectMemberFunction *mf);

  virtual StatusCode i_update(void *instance);

  virtual void i_unregister(void *instance);

  virtual void i_invalidate(void *instance);

private:

#include "UpdateManagerSvc_Item.icpp"

  GaudiUtils::HashMap<std::string, Item*> m_pathMap;

  void insertInMap( Item* it ) {
    const std::pair<const std::string,Item*> tempS( it->path, it );
    m_pathMap.insert( tempS );
  }

  inline void link(Item* parent, BaseObjectMemberFunction *mf, Item *child);

  // Disconnect a parent from the child.
  void unlink(Item *parent, Item *child);

  inline Item *findItem(const std::string &path, bool is_path_to_db = false) const;

  inline Item *findItem(void *p) const;

  inline Item *findItem(BaseObjectMemberFunction *mf) const;

  inline void removeFromHead(Item *item);

  friend class SvcFactory<UpdateManagerSvc>;

  // ---------- data members ----------
  IDataProviderSvc *m_dataProvider;

  std::string       m_dataProviderName;

  std::string       m_dataProviderRootName;

  IDetDataSvc      *m_detDataSvc;

  std::string       m_detDataSvcName;

  IIncidentSvc     *m_incidentSvc;

  IEventProcessor  *m_evtProc;

  Item::ItemList    m_all_items;
  Item::ItemList    m_head_items;
  Gaudi::Time       m_head_since;
  Gaudi::Time       m_head_until;

  std::vector<std::string> m_conditionsOveridesDesc;
  GaudiUtils::Map<std::string,Condition*> m_conditionsOverides;

  std::string m_diaDumpFile;

#ifndef WIN32
  pthread_mutex_t m_busy;
#endif

};

#include "UpdateManagerSvc.icpp"

#endif // UPDATEMANAGERSVC_H

---