IUpdateManagerSvc.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include <GaudiKernel/IInterface.h>
#include <string>
#include <typeinfo>
 
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{ 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{ 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{ instance, mf }, new PtrSetter{ 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{ 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{ 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;
};