In This Package:

IUpdateManagerSvc.h

Go to the documentation of this file.

// $Id: IUpdateManagerSvc.h,v 1.5 2007/10/31 19:02:17 marcocle Exp $
#ifndef GAUDIKERNEL_IUPDATEMANAGERSVC_H 
#define GAUDIKERNEL_IUPDATEMANAGERSVC_H 1

// Include files
// from STL
#include <string>
#include <typeinfo>

// from Gaudi
#include "GaudiKernel/IInterface.h"

// forward declarations
class DataObject;
class ValidDataObject;
class IUpdateManagerSvc;
class IDataProviderSvc;
class IDetDataSvc;
namespace Gaudi { class Time; }

static const InterfaceID IID_IUpdateManagerSvc ( "IUpdateManagerSvc", 1, 0 );

class BaseObjectMemberFunction {
public:
  virtual ~BaseObjectMemberFunction() {};

  virtual StatusCode operator() () const = 0;
        
  virtual BaseObjectMemberFunction *makeCopy() const = 0;

  virtual const std::type_info &type() const = 0;
        
  virtual bool match(BaseObjectMemberFunction *) const = 0;
        
  virtual DataObject* castToDataObject() const = 0;
  virtual ValidDataObject* castToValidDataObject() const = 0;
  virtual void* castToVoid() const = 0;
};

template <class CallerClass>
class ObjectMemberFunction: public BaseObjectMemberFunction {
public:
  typedef       StatusCode (CallerClass::*MemberFunctionType)();

  virtual ~ObjectMemberFunction() {};

  virtual StatusCode operator() () const {
    return (m_memberFunction != NULL)?
      (m_instance->*m_memberFunction)() :
      StatusCode::SUCCESS;
  }

  virtual BaseObjectMemberFunction *makeCopy() const {
    return new ObjectMemberFunction<CallerClass>(m_instance,m_memberFunction);
  }
  
  virtual const std::type_info &type() const { return typeid(CallerClass); }

  virtual bool match(BaseObjectMemberFunction *bmf) const {
    if ( bmf == (BaseObjectMemberFunction *)this ) return true;
    if (type() == bmf->type()) {
      ObjectMemberFunction * mf = dynamic_cast<ObjectMemberFunction *>(bmf);
      return m_instance == mf->m_instance &&
        m_memberFunction == mf->m_memberFunction;
    }
    return false;
  }

  virtual DataObject* castToDataObject() const {
    return dynamic_cast<DataObject*>(m_instance);
  }

  virtual ValidDataObject* castToValidDataObject() const {
    return dynamic_cast<ValidDataObject*>(m_instance);
  }

  virtual void* castToVoid() const {
    return dynamic_cast<void*>(m_instance);
  }

protected:

  ObjectMemberFunction(CallerClass *instance, const MemberFunctionType &mf):
    m_instance(instance),m_memberFunction(mf){}

  CallerClass *m_instance;

  MemberFunctionType m_memberFunction;
        
  friend class IUpdateManagerSvc;
};

class BasePtrSetter {
public:
  virtual ~BasePtrSetter() {}
  virtual void set(DataObject *) = 0;
  virtual bool isNull() = 0;
};

template<class ActualType>
class PtrSetter: public BasePtrSetter {
public:
  typedef ActualType dest_type;
  
  PtrSetter(dest_type *&dest):m_storage(&dest) {
    *m_storage = NULL;
  }    
  
  virtual ~PtrSetter() {}
  virtual void set(DataObject *obj) {
    *m_storage = dynamic_cast<dest_type *>(obj);
  }
  virtual bool isNull() { return *m_storage == NULL; }
  
private:
  dest_type **m_storage;
};

class IUpdateManagerSvc : virtual public IInterface {
public: 

  static const InterfaceID& interfaceID() { return IID_IUpdateManagerSvc; }

  virtual IDataProviderSvc *dataProvider() const = 0;

  virtual IDetDataSvc *detDataSvc() const = 0;

  template <class CallerClass>
  inline void registerCondition(CallerClass *instance, const std::string &condition = "",
                                typename ObjectMemberFunction<CallerClass>::MemberFunctionType mf = NULL){
    i_registerCondition(condition, new ObjectMemberFunction<CallerClass>(instance,mf));
  }

  template <class CallerClass, class CondType>
  inline void registerCondition(CallerClass *instance, const std::string &condition,
                                typename ObjectMemberFunction<CallerClass>::MemberFunctionType mf,
                                CondType *&condPtrDest){
    i_registerCondition(condition, new ObjectMemberFunction<CallerClass>(instance,mf),
                        new PtrSetter<CondType>(condPtrDest));
  }

  template <class CallerClass>
  inline void registerCondition(CallerClass *instance, const char *condition,
                                typename ObjectMemberFunction<CallerClass>::MemberFunctionType mf = NULL){
    i_registerCondition(std::string(condition), new ObjectMemberFunction<CallerClass>(instance,mf));
  }

  template <class CallerClass, class ObjectClass>
  inline void registerCondition(CallerClass *instance, ObjectClass *obj,
                                typename ObjectMemberFunction<CallerClass>::MemberFunctionType mf = NULL){
        i_registerCondition(dynamic_cast<void*>(obj), new ObjectMemberFunction<CallerClass>(instance,mf));
  }

  template <class CallerClass>
  inline void unregister(CallerClass *instance) {
    i_unregister(dynamic_cast<void*>(instance));
  }

  template <class CallerClass>
  inline void invalidate(CallerClass *instance) {i_invalidate(dynamic_cast<void*>(instance));}

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

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

  virtual StatusCode newEvent() = 0;
  virtual StatusCode newEvent(const Gaudi::Time &) = 0;

  template <class CallerClass>
  inline StatusCode update(CallerClass *instance){
    return i_update(dynamic_cast<void*>(instance));
  }
  
  virtual void dump() = 0;
  
  virtual void acquireLock() = 0;
  virtual void releaseLock() = 0;
  
  virtual void purge() = 0;

  class PythonHelper;

protected:

  //virtual StatusCode i_registerCondition(const std::string &condition, BaseObjectMemberFunction *mf) = 0;
  virtual void       i_registerCondition(const std::string &condition, BaseObjectMemberFunction *mf,
                                         BasePtrSetter *ptr_dest = NULL) = 0;
  virtual void       i_registerCondition(void *obj, BaseObjectMemberFunction *mf) = 0;
  virtual StatusCode i_update(void *instance) = 0;
  virtual void       i_unregister(void *instance) = 0;
  virtual void       i_invalidate(void *instance) = 0;

  friend class PythonHelper;

private:

};
#endif // GAUDIKERNEL_IUPDATEMANAGERSVC_H

---