AthCommonDataStore.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/

 
#ifndef ATHENABASECOMPS_ATHCOMMONDATASTORE_H
#define ATHENABASECOMPS_ATHCOMMONDATASTORE_H
 
#include <string>
#include <type_traits>
 
// Need to do this very early so parser for VarHandleKey picked up
#include "GaudiKernel/StatusCode.h"
namespace SG {
  class VarHandleKey;
  class VarHandleKeyArray;
  class VarHandleBase;
}
namespace Gaudi {
  namespace Parsers {
    StatusCode parse(SG::VarHandleKey& v, const std::string& s);
    StatusCode parse(SG::VarHandleKeyArray& v, const std::string& s);
    StatusCode parse(SG::VarHandleBase& v, const std::string& s);
  }
}
 
#include "AthenaBaseComps/AthMsgStreamMacros.h"
#include "AthenaBaseComps/AthCheckMacros.h"
#include "AthenaBaseComps/HandleClassifier.h"
 
#include "GaudiKernel/ServiceHandle.h"
#include "StoreGate/StoreGateSvc.h"
#include "StoreGate/VarHandleProperty.h"
#include "StoreGate/VarHandleKeyProperty.h"
#include "StoreGate/VarHandleKey.h"
#include "StoreGate/VarHandleBase.h"
#include "StoreGate/VarHandleKeyArray.h"
#include "StoreGate/VarHandleKeyArrayProperty.h"
 
 
 
template <class PBASE>
class AthCommonDataStore : public PBASE {
public:
  template <typename... T>
  AthCommonDataStore(const std::string& name, T... args)
    : PBASE(name, std::move(args)...),
      m_evtStore    ( "StoreGateSvc/StoreGateSvc",  name ),
      m_detStore    ( "StoreGateSvc/DetectorStore", name ),
      m_varHandleArraysDeclared (false)
  {
 
    this->declareProperty( "EvtStore",
                     m_evtStore = StoreGateSvc_t ("StoreGateSvc", name),
                     "Handle to a StoreGateSvc instance: it will be used to "
                     "retrieve data during the course of the job" );
    
    this->declareProperty( "DetStore",
                     m_detStore = StoreGateSvc_t ("StoreGateSvc/DetectorStore", name),
                     "Handle to a StoreGateSvc/DetectorStore instance: it will be used to "
                     "retrieve data during the course of the job" );
 
    auto props = this->getProperties();
    for( Gaudi::Details::PropertyBase* prop : props ) {
      if (prop->name() == "ExtraOutputs" || prop->name() == "ExtraInputs") {
        prop->declareUpdateHandler
          (&AthCommonDataStore<PBASE>::extraDeps_update_handler, this);
      }
    }
  }
 

  ServiceHandle<StoreGateSvc>& evtStore() { return m_evtStore; }

  const ServiceHandle<StoreGateSvc>& evtStore() const { return m_evtStore; }

  const ServiceHandle<StoreGateSvc>& detStore() const { return m_detStore; }
 

  virtual StatusCode sysInitialize() override;

  virtual StatusCode sysStart() override;
  
  virtual std::vector<Gaudi::DataHandle*> inputHandles() const override;
 

  virtual std::vector<Gaudi::DataHandle*> outputHandles() const override;
 
 
 
  /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  public:
  //
  //   style properties in AthAlgorithms
  //
 
  template <class T, class V, class H>
  Gaudi::Details::PropertyBase& declareProperty(Gaudi::Property<T,V,H> &t) {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }
 
  private:
  template <class T, class V, class H>
  Gaudi::Details::PropertyBase& declareGaudiProperty(Gaudi::Property<T,V,H> &hndl,
                                 const SG::VarHandleKeyType&)
  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

  template <class T, class V, class H>
  Gaudi::Details::PropertyBase& declareGaudiProperty(Gaudi::Property<T,V,H> &hndl,
                                 const SG::VarHandleKeyArrayType&)
  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

  template <class T, class V, class H>
  Gaudi::Details::PropertyBase& declareGaudiProperty(Gaudi::Property<T,V,H> &hndl,
                                 const SG::VarHandleType&)
  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
  }
 

  template <class T, class V, class H>
  Gaudi::Details::PropertyBase& declareGaudiProperty(Gaudi::Property<T,V,H> &t, const SG::NotHandleType&)
  {
    return PBASE::declareProperty(t);
  }
 

  //
  //
 
public:
  Gaudi::Details::PropertyBase* declareProperty(const std::string& name,
                            SG::VarHandleKey& hndl,
                            const std::string& doc,
                            const SG::VarHandleKeyType&)
  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }
 
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

  Gaudi::Details::PropertyBase* declareProperty(const std::string& name,
                            SG::VarHandleBase& hndl,
                            const std::string& doc,
                            const SG::VarHandleType&)
  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }
 
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
  Gaudi::Details::PropertyBase* declareProperty(const std::string& name,
                            SG::VarHandleKeyArray& hndArr,
                            const std::string& doc,
                            const SG::VarHandleKeyArrayType&)
  {
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray {}", name);
    }
 
    return p;
 
  }
 
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
  // Since the contents of the VarHandleKeyArrays have not been read 
  // in from the configurables by the time that declareProperty is
  // executed, we must cache them and loop through them later to
  // register the data dependencies.
  //
  // However, we cannot actually call declare() on the key instances
  // until we know that the vector cannot change size anymore --- otherwise,
  // the pointers given to declare() may become invalid.  That basically means
  // that we can't call declare() until the derived class's initialize()
  // completes.  So instead of doing it here (which would be too early),
  // we override sysInitialize() and do it at the end of that.  But,
  // Algorithm::sysInitialize() wants to have the handle lists after initialize()
  // completes in order to do dependency analysis.  It gets these lists
  // solely by calling inputHandles() and outputHandles(), so we can get this
  // to work by overriding those methods and adding in the current contents
  // of the arrays.
 
  void updateVHKA(Gaudi::Details::PropertyBase& /*p*/) {
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }
 
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 

  template <class T>
  Gaudi::Details::PropertyBase* declareProperty(const std::string& name,
                            T& property,
                            const std::string& doc,
                            const SG::NotHandleType&)
  {
    return PBASE::declareProperty(name, property, doc);
  }
 

  template <class T>
  Gaudi::Details::PropertyBase* declareProperty(const std::string& name,
                            T& property,
                            const std::string& doc="none") 
  {
    typedef typename SG::HandleClassifier<T>::type htype;
    return declareProperty (name, property, doc, htype());
  }
 
  
 
protected:
  void renounceArray( SG::VarHandleKeyArray& handlesArray ) {
    handlesArray.renounce();
  }
 
 
  // renounce() from the Gaudi base class.
  // But if the handle class also declares a renounce(), then call that first.
  // For safety, allow this only if the argument derives from Gaudi::DataHandle
  // and (to prevent confusion with the above method) it is not
  // a VarHandleKeyArray.
  using PBASE::renounce;
  template <class T>
  std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > &&
                   !std::is_base_of_v<SG::VarHandleKeyArray, T> &&
                   std::is_base_of_v<Gaudi::DataHandle, T>,
                   void>
  renounce (T& h)
  {
    h.renounce();
    PBASE::renounce (h);
  }
 
  
private:
  typedef ServiceHandle<StoreGateSvc> StoreGateSvc_t;
  StoreGateSvc_t m_evtStore;

  StoreGateSvc_t m_detStore;
 
 
private:
  // to keep track of VarHandleKeyArrays for data dep registration
  std::vector<SG::VarHandleKeyArray*> m_vhka;
  bool m_varHandleArraysDeclared;
 
 
protected:
  void extraDeps_update_handler( Gaudi::Details::PropertyBase& ExtraDeps ); 
 
 
};
 
#include "AthCommonDataStore.icc"
 
#endif