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 )();

  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