Merge branch 'expreval2' into 'master'

ExpressionEvaluation: make IProxyLoader::load interfaces const

See merge request atlas/athena!58715

PhysicsAnalysis/CommonTools/ExpressionEvaluation/ExpressionEvaluation/IProxyLoader.h

 /*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
 */
 
 /////////////////////////////////////////////////////////////////
@@ -26,10 +26,10 @@ namespace ExpressionParsing {
 
       virtual VariableType variableTypeFromString(const std::string &varname) = 0;
 
-      virtual int loadIntVariableFromString(const std::string &varname) = 0;
-      virtual double loadDoubleVariableFromString(const std::string &varname) = 0;
-      virtual std::vector<int> loadVecIntVariableFromString(const std::string &varname) = 0;
-      virtual std::vector<double> loadVecDoubleVariableFromString(const std::string &varname) = 0;
+      virtual int loadIntVariableFromString(const std::string &varname) const = 0;
+      virtual double loadDoubleVariableFromString(const std::string &varname) const = 0;
+      virtual std::vector<int> loadVecIntVariableFromString(const std::string &varname) const = 0;
+      virtual std::vector<double> loadVecDoubleVariableFromString(const std::string &varname) const = 0;
   };
 }
 

PhysicsAnalysis/CommonTools/ExpressionEvaluation/ExpressionEvaluation/MultipleProxyLoader.h

 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
 */
 
 /////////////////////////////////////////////////////////////////
@@ -29,10 +29,10 @@ namespace ExpressionParsing {
 
       virtual IProxyLoader::VariableType variableTypeFromString(const std::string &varname);
 
-      virtual int loadIntVariableFromString(const std::string &varname);
-      virtual double loadDoubleVariableFromString(const std::string &varname);
-      virtual std::vector<int> loadVecIntVariableFromString(const std::string &varname);
-      virtual std::vector<double> loadVecDoubleVariableFromString(const std::string &varname);
+      virtual int loadIntVariableFromString(const std::string &varname) const;
+      virtual double loadDoubleVariableFromString(const std::string &varname) const;
+      virtual std::vector<int> loadVecIntVariableFromString(const std::string &varname) const;
+      virtual std::vector<double> loadVecDoubleVariableFromString(const std::string &varname) const;
 
     private:
       std::vector<IProxyLoader *> m_proxyLoaders;

PhysicsAnalysis/CommonTools/ExpressionEvaluation/ExpressionEvaluation/SGNTUPProxyLoader.h

 /*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
 */
 
 /////////////////////////////////////////////////////////////////
@@ -31,10 +31,10 @@ namespace ExpressionParsing {
 
       virtual IProxyLoader::VariableType variableTypeFromString(const std::string &varname);
 
-      virtual int loadIntVariableFromString(const std::string &varname);
-      virtual double loadDoubleVariableFromString(const std::string &varname);
-      virtual std::vector<int> loadVecIntVariableFromString(const std::string &varname);
-      virtual std::vector<double> loadVecDoubleVariableFromString(const std::string &varname);
+      virtual int loadIntVariableFromString(const std::string &varname) const;
+      virtual double loadDoubleVariableFromString(const std::string &varname) const;
+      virtual std::vector<int> loadVecIntVariableFromString(const std::string &varname) const;
+      virtual std::vector<double> loadVecDoubleVariableFromString(const std::string &varname) const;
 
     private:
       StoreGateSvc_t m_evtStore;

PhysicsAnalysis/CommonTools/ExpressionEvaluation/ExpressionEvaluation/SGxAODProxyLoader.h

@@ -54,10 +54,10 @@ namespace ExpressionParsing {
 
       virtual IProxyLoader::VariableType variableTypeFromString(const std::string &varname);
 
-      virtual int loadIntVariableFromString(const std::string &varname);
-      virtual double loadDoubleVariableFromString(const std::string &varname);
-      virtual std::vector<int> loadVecIntVariableFromString(const std::string &varname);
-      virtual std::vector<double> loadVecDoubleVariableFromString(const std::string &varname);
+      virtual int loadIntVariableFromString(const std::string &varname) const;
+      virtual double loadDoubleVariableFromString(const std::string &varname) const;
+      virtual std::vector<int> loadVecIntVariableFromString(const std::string &varname) const;
+      virtual std::vector<double> loadVecDoubleVariableFromString(const std::string &varname) const;
 
      /** Interface of an auxiliary class to pass the parent, e.g. @ref AthCommonDataStore, to this loader to declare new data handles.
       */

PhysicsAnalysis/CommonTools/ExpressionEvaluation/ExpressionEvaluation/TestProxyLoader.h

 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
 */
 
 /////////////////////////////////////////////////////////////////
@@ -14,6 +14,8 @@
 
 #include "ExpressionEvaluation/IProxyLoader.h"
 
+#include <atomic>
+
 namespace ExpressionParsing {
   class TestProxyLoader : public IProxyLoader {
     public:
@@ -24,13 +26,13 @@ namespace ExpressionParsing {
 
       virtual IProxyLoader::VariableType variableTypeFromString(const std::string &varname);
 
-      virtual int loadIntVariableFromString(const std::string &varname);
-      virtual double loadDoubleVariableFromString(const std::string &varname);
-      virtual std::vector<int> loadVecIntVariableFromString(const std::string &varname);
-      virtual std::vector<double> loadVecDoubleVariableFromString(const std::string &varname);
+      virtual int loadIntVariableFromString(const std::string &varname) const;
+      virtual double loadDoubleVariableFromString(const std::string &varname) const;
+      virtual std::vector<int> loadVecIntVariableFromString(const std::string &varname) const;
+      virtual std::vector<double> loadVecDoubleVariableFromString(const std::string &varname) const;
 
     private:
-      unsigned int m_intAccessCount;
+      mutable std::atomic<unsigned int> m_intAccessCount;
   };
 }
 

PhysicsAnalysis/CommonTools/ExpressionEvaluation/ExpressionEvaluation/TriggerDecisionProxyLoader.h

 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
 */
 
 /////////////////////////////////////////////////////////////////
@@ -26,10 +26,10 @@ namespace ExpressionParsing {
       virtual ~TriggerDecisionProxyLoader();
       virtual void reset();
       virtual IProxyLoader::VariableType variableTypeFromString(const std::string &varname);
-      virtual int loadIntVariableFromString(const std::string &varname);
-      virtual double loadDoubleVariableFromString(const std::string &varname);
-      virtual std::vector<int> loadVecIntVariableFromString(const std::string &varname);
-      virtual std::vector<double> loadVecDoubleVariableFromString(const std::string &varname);
+      virtual int loadIntVariableFromString(const std::string &varname) const;
+      virtual double loadDoubleVariableFromString(const std::string &varname) const;
+      virtual std::vector<int> loadVecIntVariableFromString(const std::string &varname) const;
+      virtual std::vector<double> loadVecDoubleVariableFromString(const std::string &varname) const;
 
     private:
       ToolHandle<Trig::TrigDecisionTool> m_trigDec;

PhysicsAnalysis/CommonTools/ExpressionEvaluation/ExpressionEvaluation/xAODVariableProxyLoaders.h

@@ -152,10 +152,10 @@ namespace ExpressionParsing {
       void setData(const SG::AuxElement *auxElement);
 
       virtual IProxyLoader::VariableType variableTypeFromString(const std::string &varname);
-      virtual int loadIntVariableFromString(const std::string &varname);
-      virtual double loadDoubleVariableFromString(const std::string &varname);
-      virtual std::vector<int> loadVecIntVariableFromString(const std::string &varname);
-      virtual std::vector<double> loadVecDoubleVariableFromString(const std::string &varname);
+      virtual int loadIntVariableFromString(const std::string &varname) const;
+      virtual double loadDoubleVariableFromString(const std::string &varname) const;
+      virtual std::vector<int> loadVecIntVariableFromString(const std::string &varname) const;
+      virtual std::vector<double> loadVecDoubleVariableFromString(const std::string &varname) const;
 
     private:
       const SG::AuxElement *m_auxElement;
@@ -174,10 +174,10 @@ namespace ExpressionParsing {
       void setData(const SG::AuxVectorData *auxElement);
 
       virtual IProxyLoader::VariableType variableTypeFromString(const std::string &varname);
-      virtual int loadIntVariableFromString(const std::string &varname);
-      virtual double loadDoubleVariableFromString(const std::string &varname);
-      virtual std::vector<int> loadVecIntVariableFromString(const std::string &varname);
-      virtual std::vector<double> loadVecDoubleVariableFromString(const std::string &varname);
+      virtual int loadIntVariableFromString(const std::string &varname) const;
+      virtual double loadDoubleVariableFromString(const std::string &varname) const;
+      virtual std::vector<int> loadVecIntVariableFromString(const std::string &varname) const;
+      virtual std::vector<double> loadVecDoubleVariableFromString(const std::string &varname) const;
 
     private:
       const SG::AuxVectorData *m_auxVectorData;

PhysicsAnalysis/CommonTools/ExpressionEvaluation/Root/MultipleProxyLoader.cxx

 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
 */
 
 /////////////////////////////////////////////////////////////////
@@ -58,23 +58,23 @@ namespace ExpressionParsing {
     return result;
   }
 
-  int MultipleProxyLoader::loadIntVariableFromString(const std::string &varname)
+  int MultipleProxyLoader::loadIntVariableFromString(const std::string &varname) const
   {
-    return m_varnameToProxyLoader[varname]->loadIntVariableFromString(varname);
+    return m_varnameToProxyLoader.at(varname)->loadIntVariableFromString(varname);
   }
 
-  double MultipleProxyLoader::loadDoubleVariableFromString(const std::string &varname)
+  double MultipleProxyLoader::loadDoubleVariableFromString(const std::string &varname) const
   {
-    return m_varnameToProxyLoader[varname]->loadDoubleVariableFromString(varname);
+    return m_varnameToProxyLoader.at(varname)->loadDoubleVariableFromString(varname);
   }
 
-  std::vector<int> MultipleProxyLoader::loadVecIntVariableFromString(const std::string &varname)
+  std::vector<int> MultipleProxyLoader::loadVecIntVariableFromString(const std::string &varname) const
   {
-    return m_varnameToProxyLoader[varname]->loadVecIntVariableFromString(varname);
+    return m_varnameToProxyLoader.at(varname)->loadVecIntVariableFromString(varname);
   }
 
-  std::vector<double> MultipleProxyLoader::loadVecDoubleVariableFromString(const std::string &varname)
+  std::vector<double> MultipleProxyLoader::loadVecDoubleVariableFromString(const std::string &varname) const
   {
-    return m_varnameToProxyLoader[varname]->loadVecDoubleVariableFromString(varname);
+    return m_varnameToProxyLoader.at(varname)->loadVecDoubleVariableFromString(varname);
   }
 }

PhysicsAnalysis/CommonTools/ExpressionEvaluation/Root/TestProxyLoader.cxx

 /*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
 */
 
 /////////////////////////////////////////////////////////////////
@@ -33,26 +33,26 @@ namespace ExpressionParsing {
     else return VT_UNK;
   }
 
-  int TestProxyLoader::loadIntVariableFromString(const std::string &varname)
+  int TestProxyLoader::loadIntVariableFromString(const std::string &varname) const
   {
     if (varname == "intTEST") { ++m_intAccessCount; return (42+(m_intAccessCount-1)); }
     else if (varname == "int_TEST") { return 24; }
     else throw std::runtime_error("Unknown proxy: " + varname);
   }
 
-  double TestProxyLoader::loadDoubleVariableFromString(const std::string &varname)
+  double TestProxyLoader::loadDoubleVariableFromString(const std::string &varname) const
   {
     if (varname == "doubleTEST") return 42.42;
     else throw std::runtime_error("Unknown proxy: " + varname);
   }
 
-  std::vector<int> TestProxyLoader::loadVecIntVariableFromString(const std::string &varname)
+  std::vector<int> TestProxyLoader::loadVecIntVariableFromString(const std::string &varname) const
   {
     if (varname == "vectorIntTEST") return std::vector<int>(2, 42);
     else throw std::runtime_error("Unknown proxy: " + varname);
   }
 
-  std::vector<double> TestProxyLoader::loadVecDoubleVariableFromString(const std::string &varname)
+  std::vector<double> TestProxyLoader::loadVecDoubleVariableFromString(const std::string &varname) const
   {
     if (varname == "vectorDoubleTEST") return std::vector<double>(2, 42.42);
     else throw std::runtime_error("Unknown proxy: " + varname);

PhysicsAnalysis/CommonTools/ExpressionEvaluation/Root/xAODVariableProxyLoaders.cxx

@@ -288,22 +288,22 @@ namespace ExpressionParsing {
     return VT_UNK;
   }
 
-  int xAODElementProxyLoader::loadIntVariableFromString(const std::string &varname)
+  int xAODElementProxyLoader::loadIntVariableFromString(const std::string &varname) const
   {
-    return m_accessorCache[varname]->getIntValue(m_auxElement);
+    return m_accessorCache.at(varname)->getIntValue(m_auxElement);
   }
 
-  double xAODElementProxyLoader::loadDoubleVariableFromString(const std::string &varname)
+  double xAODElementProxyLoader::loadDoubleVariableFromString(const std::string &varname) const
   {
-    return m_accessorCache[varname]->getDoubleValue(m_auxElement);
+    return m_accessorCache.at(varname)->getDoubleValue(m_auxElement);
   }
 
-  std::vector<int> xAODElementProxyLoader::loadVecIntVariableFromString(const std::string &)
+  std::vector<int> xAODElementProxyLoader::loadVecIntVariableFromString(const std::string &) const
   {
     throw std::runtime_error("xAODElementProxyLoader can't load vector types");
   }
 
-  std::vector<double> xAODElementProxyLoader::loadVecDoubleVariableFromString(const std::string &)
+  std::vector<double> xAODElementProxyLoader::loadVecDoubleVariableFromString(const std::string &) const
   {
     throw std::runtime_error("xAODElementProxyLoader can't load vector types");
   }
@@ -360,25 +360,25 @@ namespace ExpressionParsing {
     return VT_UNK;
   }
 
-  int xAODVectorProxyLoader::loadIntVariableFromString(const std::string &)
+  int xAODVectorProxyLoader::loadIntVariableFromString(const std::string &) const
   {
     throw std::runtime_error("xAODVectorProxyLoader can't load scalar types");
   }
 
-  double xAODVectorProxyLoader::loadDoubleVariableFromString(const std::string &)
+  double xAODVectorProxyLoader::loadDoubleVariableFromString(const std::string &) const
   {
     throw std::runtime_error("xAODVectorProxyLoader can't load scalar types");
   }
 
-  std::vector<int> xAODVectorProxyLoader::loadVecIntVariableFromString(const std::string &varname)
+  std::vector<int> xAODVectorProxyLoader::loadVecIntVariableFromString(const std::string &varname) const
   {
-    return m_accessorCache[varname]->getVecIntValue(m_auxVectorData);
+    return m_accessorCache.at(varname)->getVecIntValue(m_auxVectorData);
   }
 
-  std::vector<double> xAODVectorProxyLoader::loadVecDoubleVariableFromString(const std::string &varname)
-  {
+  std::vector<double> xAODVectorProxyLoader::loadVecDoubleVariableFromString(const std::string &varname) const
+  {/*
      // Check whether we have an accessor already:
-     std::map< std::string, BaseAccessorWrapper* >::iterator itr;
+     std::map< std::string, BaseAccessorWrapper* >::const_iterator itr;
      if( ( itr = m_accessorCache.find( varname ) ) == m_accessorCache.end() ) {
         // For an empty container let's not bother too much:
         if( m_auxVectorData->size_v() == 0 ) {
@@ -396,7 +396,8 @@ namespace ExpressionParsing {
      // Now do the "regular thing". Note that even if the type turns out
      // to be an integer type, the accessor wrapper does the conversion
      // reasonably anyway, behind the scenes.
-     return itr->second->getVecDoubleValue(m_auxVectorData);
+     return itr->second->getVecDoubleValue(m_auxVectorData);*/
+    return m_accessorCache.at(varname)->getVecDoubleValue(m_auxVectorData);
   }
 
 }

PhysicsAnalysis/CommonTools/ExpressionEvaluation/src/SGNTUPProxyLoader.cxx

@@ -57,7 +57,7 @@ namespace ExpressionParsing {
     else return VT_UNK;
   }
 
-  int SGNTUPProxyLoader::loadIntVariableFromString(const std::string &varname)
+  int SGNTUPProxyLoader::loadIntVariableFromString(const std::string &varname) const
   {
     SG_GET_SCALAR(int, int);
     SG_GET_SCALAR(int, bool);
@@ -65,14 +65,14 @@ namespace ExpressionParsing {
     throw std::runtime_error("Unknown int-like proxy: " + varname);
   }
 
-  double SGNTUPProxyLoader::loadDoubleVariableFromString(const std::string &varname)
+  double SGNTUPProxyLoader::loadDoubleVariableFromString(const std::string &varname) const
   {
     SG_GET_SCALAR(double, float);
     SG_GET_SCALAR(double, double);
     throw std::runtime_error("Unknown double-like proxy: " + varname);
   }
 
-  std::vector<int> SGNTUPProxyLoader::loadVecIntVariableFromString(const std::string &varname)
+  std::vector<int> SGNTUPProxyLoader::loadVecIntVariableFromString(const std::string &varname) const
   {
     SG_GET_VECTOR(int, int);
     SG_GET_VECTOR(int, bool);
@@ -80,7 +80,7 @@ namespace ExpressionParsing {
     throw std::runtime_error("Unknown vector<int>-like proxy: " + varname);
   }
 
-  std::vector<double> SGNTUPProxyLoader::loadVecDoubleVariableFromString(const std::string &varname)
+  std::vector<double> SGNTUPProxyLoader::loadVecDoubleVariableFromString(const std::string &varname) const
   {
     SG_GET_VECTOR(double, float);
     SG_GET_VECTOR(double, double);

PhysicsAnalysis/CommonTools/ExpressionEvaluation/src/SGxAODProxyLoader.cxx

@@ -213,25 +213,25 @@ namespace ExpressionParsing {
       }
    }
 
-  int SGxAODProxyLoader::loadIntVariableFromString(const std::string &varname)
+  int SGxAODProxyLoader::loadIntVariableFromString(const std::string &varname) const
   {
     const EventContext& ctx = Gaudi::Hive::currentContext();
     return dump(varname,getAccessor(ctx, varname).loadInt(ctx));
   }
 
-  double SGxAODProxyLoader::loadDoubleVariableFromString(const std::string &varname)
+  double SGxAODProxyLoader::loadDoubleVariableFromString(const std::string &varname) const
   {
     const EventContext& ctx = Gaudi::Hive::currentContext();
     return dump(varname,getAccessor(ctx, varname).loadDouble(ctx));
   }
 
-  std::vector<int> SGxAODProxyLoader::loadVecIntVariableFromString(const std::string &varname)
+  std::vector<int> SGxAODProxyLoader::loadVecIntVariableFromString(const std::string &varname) const
   {
     const EventContext& ctx = Gaudi::Hive::currentContext();
     return dump(varname,getAccessor(ctx, varname).loadVecInt(ctx));
   }
 
-  std::vector<double> SGxAODProxyLoader::loadVecDoubleVariableFromString(const std::string &varname)
+  std::vector<double> SGxAODProxyLoader::loadVecDoubleVariableFromString(const std::string &varname) const
   {
     const EventContext& ctx = Gaudi::Hive::currentContext();
     return dump(varname,getAccessor(ctx, varname).loadVec(ctx));

PhysicsAnalysis/CommonTools/ExpressionEvaluation/src/TriggerDecisionProxyLoader.cxx

@@ -35,7 +35,7 @@ namespace ExpressionParsing {
     else return VT_UNK;    
   }
 
-  int TriggerDecisionProxyLoader::loadIntVariableFromString(const std::string &varname)
+  int TriggerDecisionProxyLoader::loadIntVariableFromString(const std::string &varname) const
   {
     bool passed(false);
     if ( varname == "" ) return(0); // no name => ?
@@ -45,17 +45,17 @@ namespace ExpressionParsing {
     else return(0); 
   }
 
-  double TriggerDecisionProxyLoader::loadDoubleVariableFromString(const std::string &varname)
+  double TriggerDecisionProxyLoader::loadDoubleVariableFromString(const std::string &varname) const
   {
     throw std::runtime_error("Trigger decision can't be a double: check " + varname);
   }
 
-  std::vector<int> TriggerDecisionProxyLoader::loadVecIntVariableFromString(const std::string &varname)
+  std::vector<int> TriggerDecisionProxyLoader::loadVecIntVariableFromString(const std::string &varname) const
   {
     throw std::runtime_error("Trigger decision can't be vector<int>: check " + varname);
   }
 
-  std::vector<double> TriggerDecisionProxyLoader::loadVecDoubleVariableFromString(const std::string &varname)
+  std::vector<double> TriggerDecisionProxyLoader::loadVecDoubleVariableFromString(const std::string &varname) const
   {
     throw std::runtime_error("Trigger decision can't be vector<double>: check " + varname);
   }