GenAccessor.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#ifndef _ExpressionEvaluation_GenAccessor_h_
#define _ExpressionEvaluation_GenAccessor_h_
 
#include "StoreGate/ReadHandleKey.h"
#include "StoreGate/ReadHandle.h"
#include "ExpressionEvaluation/IProxyLoader.h"
 
#include "BaseAccessor.h"
 
#include <vector>
 
namespace ExpressionParsing {

   class ScalarHelper {
   public:
      template <class T_Dest, class T_Cont, class T_Helper>
      static void fillVector(T_Helper &helper, SG::ReadHandle<T_Cont> &handle, std::vector<T_Dest> &result) {
         result.reserve(1);
         auto val = helper.get( *handle );
         // @TODO or throw an exception if the type conversion is not loss-less?
         assert( val == static_cast<decltype(val)>(static_cast<T_Dest>(val)));
         result.push_back( static_cast<T_Dest>(val));
      }
 
      template <class T_Dest, class T_Cont, class T_Helper>
      static T_Dest getScalar(T_Helper &helper, SG::ReadHandle<T_Cont> &handle,const T_Dest &dummy) {
         (void) dummy;
         auto val = helper.get( *handle );
         // @TODO or throw an exception if the type conversion is not loss-less?
         assert( val == static_cast<decltype(val)>(static_cast<T_Dest>(val)));
         return static_cast<T_Dest>( val );
      }
   };

   class VectorHelper {
   public:
      template <class T_Dest, class T_Cont, class T_Helper>
      static void fillVector(T_Helper &helper, SG::ReadHandle<T_Cont> &handle, std::vector<T_Dest> &result) {
         std::size_t n_elements=helper.size(*handle);
         //         helper.checkSize(n_elements);
         result.reserve(n_elements);
         for(std::size_t idx =0; idx <n_elements; ++idx) {
            auto val = helper.get(*handle, idx);
            // @TODO or throw an exception if the type conversion is not loss-less?
            assert( val == static_cast<decltype(val)>(static_cast<T_Dest>(val)));
            result.push_back( static_cast<T_Dest>( val ) );
         }
      }
      template <class T_Dest, class T_Cont, class T_Helper>
      static T_Dest getScalar(T_Helper &helper, SG::ReadHandle<T_Cont> &handle, const T_Dest &dummy) {
         (void) dummy;
         if (getContainerSize(*handle) != 1) {
            BaseAccessor::throwVectorContainsNotOneElement(handle.key(), getContainerSize(*handle));
         }
         auto val = helper.get(*handle, 0);
         // @TODO or throw an exception if the type conversion is not loss-less?
         assert( val == static_cast<decltype(val)>(static_cast<T_Dest>(val)));
         return static_cast<T_Dest>(val);
      }
   };

   template <class T_Cont, class T_HelperKit, class T_ScalarVectorHelper>
   class GenAccessor : public BaseAccessor {
   public:
      GenAccessor(const SG::ReadHandleKey<T_Cont> &key, T_HelperKit &&helper_kit, IAccessor::VariableType variable_type)
         : BaseAccessor(variable_type),
           m_key(&key),
           m_helperKit(std::move(helper_kit))
      {}
 
      virtual int loadInt(const EventContext& ctx, [[maybe_unused]] const std::string &var_name) const override {
         return this->loadScalar<int>(ctx);
      }
      virtual double loadDouble(const EventContext& ctx, [[maybe_unused]] const std::string &var_name) const override {
         return this->loadScalar<double>(ctx);
      }
      virtual std::vector<int> loadVecInt(const EventContext& ctx, [[maybe_unused]] const std::string &var_name) const override {
         return this->loadVector<int>(ctx);
      }
      virtual std::vector<double> loadVec(const EventContext& ctx, [[maybe_unused]] const std::string &var_name) const override {
         return this->loadVector<double>(ctx);
      }
   protected:
      template <class T_Dest>
      std::vector<T_Dest> loadVector(const EventContext& ctx) const {
         SG::ReadHandle<T_Cont> handle(*this->m_key, ctx);
         if (!handle.isValid()) {
            this->throwInvalidHandle(this->m_key->key());
         }
         std::vector<T_Dest> result;
         if (getContainerSize(*handle)>0) {
            auto helper( m_helperKit.create(ctx, handle));
            T_ScalarVectorHelper::fillVector(helper, handle,result);
         }
         return result;
      }
 
      template <class T_Dest>
      T_Dest loadScalar(const EventContext& ctx) const {
         SG::ReadHandle<T_Cont> handle(*this->m_key, ctx);
         if (!handle.isValid()) {
            this->throwInvalidHandle(this->m_key->key());
         }
         auto helper( m_helperKit.create(ctx, handle));
         T_Dest dummy {};
         return T_ScalarVectorHelper::getScalar(helper, handle, dummy);
      }
 
      const SG::ReadHandleKey<T_Cont>      *m_key;  //< key to access the xAOD container
      T_HelperKit                      m_helperKit; //< auxiliary class to create an access helper
   };
}
#endif