SGxAODProxyLoader.h

Go to the documentation of this file.

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

// SGxAODProxyLoader.h, (c) ATLAS Detector software
// Author: Thomas Gillam (thomas.gillam@cern.ch)
// ExpressionParsing library
 
#ifndef SG_XAOD_PROXY_LOADER_H
#define SG_XAOD_PROXY_LOADER_H
 
#include "ExpressionEvaluation/IProxyLoader.h"
 
#include "GaudiKernel/ServiceHandle.h"
#include "StoreGate/StoreGateSvc.h"
#include "SGTools/StlVectorClids.h"
#include "SGTools/BuiltinsClids.h"
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/ReadDecorHandleKey.h"
#include "StoreGate/ReadDecorHandle.h"
#include "AthContainers/AuxVectorBase.h"
 
#include "RootUtils/TSMethodCall.h"
 
#include "CxxUtils/CachedUniquePtr.h"
#include <any>
 
#include "IAccessor.h"
 
class TMethodCall;
class TVirtualCollectionProxy;
 
namespace SG {
   class AuxVectorBase;
   class AuxElement;
}
#include <map>
 
namespace ExpressionParsing {
 

  class SGxAODProxyLoader : public IProxyLoader {
 
    public:
      typedef ServiceHandle<StoreGateSvc> StoreGateSvc_t;
      SGxAODProxyLoader(StoreGateSvc_t &evtStore, bool verbose=false);
      virtual ~SGxAODProxyLoader();
 
      virtual void reset() override;
 
      virtual VariableType variableType(const std::string &var_name) const override;
 
      virtual std::pair< IProxyLoader::VariableType, const IAccessor &>
              getAccessorFromString(const EventContext &ctx, const std::string &varname) const override;
 
      virtual int loadInt(const EventContext& ctx,const std::string &varname) const override;
      virtual double loadDouble(const EventContext& ctx,const std::string &varname) const override;
      virtual std::vector<int> loadVecInt(const EventContext& ctx,const std::string &varname) const override;
      virtual std::vector<double> loadVec(const EventContext& ctx,const std::string &varname) const override;

      class IParentHelper {
      public:
         ~IParentHelper() {}
         virtual StatusCode declare(SG::VarHandleKey &handle) = 0;
      };

      template <class T>
      class ParentHelper : public IParentHelper {
      public:
         ParentHelper(T *parent) : m_parent(parent) {}
         virtual StatusCode declare(SG::VarHandleKey &handle) override {
            m_parent->declare(handle);
            handle.setOwner(m_parent);
            return handle.initialize();
         }
      private:
         T *m_parent;
      };

      template <class T>
      static ParentHelper<T> wrapParent(T *parent) {
         return ParentHelper<T>(parent);
      }

      bool updateDataDependencies(SGxAODProxyLoader::IParentHelper &parent,
                                  const std::vector<std::string> &var_names,
                                  const std::vector<std::string>  &renounce,
                                  const std::vector<const DataObjID *> &input_data_in,
                                  const std::vector<const DataObjID *> &output_data_in,
                                  std::vector<Gaudi::DataHandle *> &new_input_handles,
                                  std::vector<Gaudi::DataHandle *> &new_output_handles);
 
    private:
      void splitVarnameIntoContainerAndMethod(const std::string &varname, std::string &containerName, std::string &methodName) const;

      IAccessor &computeClassForVarname(const EventContext& ctx,
                                        std::unordered_map<std::string, CxxUtils::CachedUniquePtrT<IAccessor> >::const_iterator accessor_iter,
                                        const std::string &varname) const;

      std::pair<RootUtils::TSMethodCall, TVirtualCollectionProxy *>
      getMethodCallAccessor(const std::string &method_name, const std::type_info &info) const;

      IAccessor &getAccessor(const EventContext& ctx, const std::string &varname) const {
         std::unordered_map<std::string, CxxUtils::CachedUniquePtrT<IAccessor> >::const_iterator
            accessor_iter = m_accessor.find(varname);
         if (accessor_iter == m_accessor.end()) {
            std::stringstream msg;
            msg << "No accessor stub was created for  " << varname << " i.e. variable is unknown.";
            throw std::runtime_error(msg.str());
         }
         if (accessor_iter->second) return *(accessor_iter->second);
         return computeClassForVarname(ctx,accessor_iter, varname);
      }

      template <class T_Aux>
      std::unique_ptr<IAccessor> createAccessor(const EventContext& ctx,
                                                const SG::ReadHandleKey<T_Aux> &key,
                                                const SG::ReadDecorHandleKey<T_Aux> *decor_key,
                                                SG::auxid_t method_id,
                                                const std::string &method_name) const;
 
      StoreGateSvc_t m_evtStore;

      template <class T_Element_Key, class T_Vector_Key>
      class ReadHandleMapTmpl : public std::unordered_map<std::string, std::any > {
      public:
         template <class T>
         static T &checkedRef(T *a) {
            if (!a) {
               std::stringstream msg; msg << "Conversion to " << typeid(T).name() << " failed.";
               throw std::runtime_error(msg.str());
            }
            return *a;
         }

         static bool isVector(const std::any &anything)                    { return anything.type() == typeid(T_Vector_Key); }
         static bool isElement(const std::any &anything)                   { return anything.type() == typeid(T_Element_Key); }
         static T_Element_Key &elementKey(std::any &anything)              { return checkedRef(std::any_cast<T_Element_Key>(&anything)); }
         static T_Vector_Key &vectorKey(std::any &anything)                { return checkedRef(std::any_cast<T_Vector_Key>(&anything)); }
         static const T_Element_Key &elementKey(const std::any &anything)  { return checkedRef(std::any_cast<T_Element_Key>(&anything)); }
         static const T_Vector_Key &vectorKey(const std::any &anything)    { return checkedRef(std::any_cast<T_Vector_Key>(&anything)); }
      };
      using ReadHandleMap = ReadHandleMapTmpl<SG::ReadHandleKey<SG::AuxElement>,
                                              SG::ReadHandleKey<SG::AuxVectorBase> >;
      using ReadDecorHandleMap = ReadHandleMapTmpl<SG::ReadDecorHandleKey<SG::AuxElement>,
                                                   SG::ReadDecorHandleKey<SG::AuxVectorBase> >;
      ReadHandleMap      m_readKeys;  //< Association of variable names and read handle keys to AuxElement or AuxVectorBase.
      ReadDecorHandleMap m_decorKeys; //< Association of variable names and read decoration handle keys for  AuxElement or AuxVectorBase.

      std::unordered_map<std::string, CxxUtils::CachedUniquePtrT<IAccessor> > m_accessor;

      std::unique_ptr<IAccessor>    m_emptyVectorAccessor;
      bool m_verbose = false;
  };
 
}
 
#endif // SG_XAOD_PROXY_LOADER_H