IUpdateManagerSvc.h

Go to the documentation of this file.

#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; }

class BaseObjectMemberFunction {
public:
  virtual ~BaseObjectMemberFunction() = default;

  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 final : public BaseObjectMemberFunction {
public:
  typedef   StatusCode (CallerClass::*MemberFunctionType)();

  ~ObjectMemberFunction() override = default;

  StatusCode operator() () const override {
    return m_memberFunction? (m_instance->*m_memberFunction)()
                           : StatusCode::SUCCESS;
  }

  BaseObjectMemberFunction *makeCopy() const override {
    return new ObjectMemberFunction<CallerClass>(m_instance,m_memberFunction);
  }

  const std::type_info &type() const override { return typeid(CallerClass); }

  bool match(BaseObjectMemberFunction *bmf) const override {
    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;
  }

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

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

  void* castToVoid() const override {
    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() = default;
  virtual void set(DataObject *) = 0;
  virtual bool isNull() = 0;
};


class GAUDI_API IUpdateManagerSvc: virtual public IInterface {
private:
  template<class ActualType>
  class PtrSetter final : public BasePtrSetter {
  public:
    using dest_type = ActualType;
    PtrSetter(dest_type *&dest):m_storage(&dest) {
      *m_storage = nullptr;
    }
    void set(DataObject *obj) override {
      *m_storage = dynamic_cast<dest_type *>(obj);
    }
    bool isNull() override { return *m_storage == nullptr; }

  private:
    dest_type **m_storage;
  };
public:
  DeclareInterfaceID(IUpdateManagerSvc,2,0);

  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 = nullptr){
    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 = nullptr){
    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 = nullptr){
    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 = nullptr) = 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;
};
#endif // GAUDIKERNEL_IUPDATEMANAGERSVC_H