Calorimeter/CaloCalibHitRec/CaloCalibHitRec/ATLAS_CHECK_THREAD_SAFETY

+Calorimeter/CaloCalibHitRec

Calorimeter/CaloCalibHitRec/src/CaloCalibClusterMomentsMaker2.cxx

@@ -820,7 +820,6 @@ Calculation of energy fraction caused by particles of different types
 void CaloCalibClusterMomentsMaker2::get_calib_frac(const std::map<unsigned int,int>& truthBarcodeToPdgCodeMap,
                                                    const MyClusInfo& clusInfo, std::vector<double> &engFrac) const
 {
-  static unsigned int nWarnings = 0;
   engFrac.assign(kCalibFracMax, 0.0);
   if(clusInfo.engCalibIn.engTot <= 0.0) return;
   // each MyClusInfo has a map of particle's barcode and particle calibration deposits in given cluster
@@ -829,10 +828,7 @@ void CaloCalibClusterMomentsMaker2::get_calib_frac(const std::map<unsigned int,i
     int pdg_id = 0;
     try { pdg_id = truthBarcodeToPdgCodeMap.at(barcode); }
     catch (const std::out_of_range& e){
-      if (nWarnings < 10 ){
-	ATH_MSG_WARNING("truthBarcodeToPdgCodeMap cannot find an entry with barcode " << barcode);
-	nWarnings++;
-      }
+      ATH_MSG_WARNING("truthBarcodeToPdgCodeMap cannot find an entry with barcode " << barcode);
       continue;
     }
 

Calorimeter/CaloConditions/CaloConditions/CaloBadChannel.h

@@ -16,14 +16,9 @@ class CaloBadChannel {
   CaloBadChannel( BitWord rawStatus) : m_word(rawStatus) {}
   CaloBadChannel() : m_word(0) {}
 
-  CaloBadChannel(const CaloBadChannel& rBad) {m_word=rBad.m_word;}
+  CaloBadChannel(const CaloBadChannel& rBad) = default;
   CaloBadChannel(const CaloBadChannel* pBad) {m_word=pBad->m_word;}
-  CaloBadChannel& operator= (const CaloBadChannel& rBad) {
-    if (this != &rBad) {
-      m_word = rBad.m_word;
-    }
-    return *this;
-  }
+  CaloBadChannel& operator= (const CaloBadChannel& rBad) = default;
 
   bool statusOK( ProblemType pb) const {
     BitWord mask = 1 << (PosType) pb;

Calorimeter/CaloConditions/CaloConditions/CaloLocalHadCoeff.h

@@ -82,9 +82,13 @@ class CaloLocalHadCoeff {
         /**
          * @brief Copy constructor
          */
-        LocalHadDimension(const LocalHadDimension &other);
-        LocalHadDimension& operator= (const LocalHadDimension &other);
-
+        LocalHadDimension(const LocalHadDimension &other) = default;
+        LocalHadDimension& operator= (const LocalHadDimension &other) = default;
+        /**
+         * @brief Move constructor
+         */
+        LocalHadDimension( LocalHadDimension &&) noexcept = default;
+        LocalHadDimension& operator= ( LocalHadDimension &&)  noexcept = default;
         // access methods
 
         /// return dimension type
@@ -157,8 +161,10 @@ class CaloLocalHadCoeff {
         /**
          * @brief Copy constructor
          */
-        LocalHadArea(const LocalHadArea &other);
-        LocalHadArea& operator= (const LocalHadArea &other);
+        LocalHadArea(const LocalHadArea &other) = default;
+        LocalHadArea& operator= (const LocalHadArea &other) = default;
+        LocalHadArea( LocalHadArea &&other) noexcept = default;
+        LocalHadArea& operator= ( LocalHadArea &&other) noexcept = default;
 
         /// return area type
         inline unsigned int getType() const { return m_type; }
@@ -220,8 +226,11 @@ class CaloLocalHadCoeff {
     /**
      * @brief Copy constructor.
      */
-    CaloLocalHadCoeff(const CaloLocalHadCoeff &other);
-    CaloLocalHadCoeff& operator= (const CaloLocalHadCoeff &other);
+    CaloLocalHadCoeff(const CaloLocalHadCoeff &other) = default;
+    CaloLocalHadCoeff& operator= (const CaloLocalHadCoeff &other) = default;
+    //Move operators
+    CaloLocalHadCoeff(CaloLocalHadCoeff &&) noexcept = default;
+    CaloLocalHadCoeff& operator= (CaloLocalHadCoeff &&) noexcept = default;
 
     //
     // general access methods

Calorimeter/CaloConditions/src/CaloLocalHadCoeff.cxx

@@ -21,32 +21,6 @@
 LocalHadDimension ->
 *************************************************************************** */
 
-// copy constructor
-CaloLocalHadCoeff::LocalHadDimension::LocalHadDimension(const CaloLocalHadCoeff::LocalHadDimension &other)
-  : m_title (other.m_title),
-    m_type (other.m_type),
-    m_nbins (other.m_nbins),
-    m_xmin (other.m_xmin),
-    m_xmax (other.m_xmax),
-    m_dx (other.m_dx),
-    m_xbins (other.m_xbins)
-{
-}
-
-CaloLocalHadCoeff::LocalHadDimension&
-CaloLocalHadCoeff::LocalHadDimension::operator= (const CaloLocalHadCoeff::LocalHadDimension &other)
-{
-  if (this != &other) {
-    m_title = other.m_title;
-    m_type = other.m_type;
-    m_nbins = other.m_nbins;
-    m_xmin = other.m_xmin;
-    m_xmax = other.m_xmax;
-    m_dx = other.m_dx;
-    m_xbins = other.m_xbins;
-  }
-  return *this;
-}
 
 // return bin number for cluster variable
 int CaloLocalHadCoeff::LocalHadDimension::getBin(float &x) const
@@ -157,32 +131,6 @@ bool CaloLocalHadCoeff::isFilled(const int bin) const
 /* ***************************************************************************
 LocalHadArea ->
 *************************************************************************** */
-// copy constructor
-CaloLocalHadCoeff::LocalHadArea::LocalHadArea(const CaloLocalHadCoeff::LocalHadArea &other)
-  : m_title (other.m_title),
-    m_type (other.m_type),
-    m_npars (other.m_npars),
-    m_offset (other.m_offset),
-    m_length (other.m_length),
-    m_dims (other.m_dims),
-    m_dims_loc (other.m_dims_loc)
-{
-}
-
-CaloLocalHadCoeff::LocalHadArea&
-CaloLocalHadCoeff::LocalHadArea::operator=(const CaloLocalHadCoeff::LocalHadArea &other)
-{
-  if (this != &other) {
-    m_title = other.m_title;
-    m_type = other.m_type;
-    m_npars = other.m_npars;
-    m_offset = other.m_offset;
-    m_length = other.m_length;
-    m_dims = other.m_dims;
-    m_dims_loc = other.m_dims_loc;
-  }
-  return *this;
-}
 
 // add new dimension to the area
 void CaloLocalHadCoeff::LocalHadArea::addDimension(CaloLocalHadCoeff::LocalHadDimension &dim)
@@ -214,27 +162,9 @@ CaloLocalHadCoeff
 // default constructor
 CaloLocalHadCoeff::CaloLocalHadCoeff()
 {
-
-}
-
-// copy constructor
-CaloLocalHadCoeff::CaloLocalHadCoeff(const CaloLocalHadCoeff &other)
-  : m_title (other.m_title),
-    m_CoeffSet (other.m_CoeffSet),
-    m_AreaSet (other.m_AreaSet)
-{
-}
-
-
-
-CaloLocalHadCoeff& CaloLocalHadCoeff::operator=(const CaloLocalHadCoeff &other)
-{
-  if (this != &other) {
-    m_AreaSet = other.m_AreaSet;
-    m_CoeffSet = other.m_CoeffSet;
-    m_title = other.m_title;
-  }
-  return *this;
+   static_assert(std::is_nothrow_move_constructible<CaloLocalHadCoeff>::value);
+   static_assert(std::is_nothrow_move_constructible<LocalHadArea>::value);
+   static_assert(std::is_nothrow_move_constructible<LocalHadDimension>::value);
 }
 
 

Calorimeter/CaloRec/src/CaloTopoTmpHashCell.h

@@ -40,10 +40,7 @@ public:
   }
 
 
-  CaloTopoTmpHashCell(const CaloTopoTmpHashCell &other)
-  {
-    m_clusterCell = other.m_clusterCell;
-  }
+  CaloTopoTmpHashCell(const CaloTopoTmpHashCell &other) = default;
 
 
   CaloTopoTmpHashCell(T* clusterCell) 
@@ -58,13 +55,7 @@ public:
     return (m_clusterCell == other.m_clusterCell);
   }
 
-  CaloTopoTmpHashCell & operator=(const CaloTopoTmpHashCell & other)
-  {
-    if ( this != &other ) {
-      m_clusterCell = other.m_clusterCell;
-    }
-    return *this;
-  }
+  CaloTopoTmpHashCell & operator=(const CaloTopoTmpHashCell & other) = default;
 
   T * getCaloTopoTmpClusterCell() const
   {

Control/AthLinks/AthLinks/ElementLinkVector.h

@@ -187,7 +187,7 @@ public:
 
   /// \name vector constructors (no Allocators)
   //@{
-  ElementLinkVector() : ElementLinkVectorBase() { }
+  ElementLinkVector();
  
   ElementLinkVector(size_type n, const ElemLink& link) :
     ElementLinkVectorBase(), m_shortRefs(n, ElemLinkRef(link))
@@ -217,7 +217,7 @@ public:
     ElementLinkVectorBase( vec ),
     m_shortRefs(vec.m_shortRefs), m_hostDObjs(vec.m_hostDObjs) { }
 
-  ElementLinkVector(ElemLinkVec&& vec) :
+  ElementLinkVector(ElemLinkVec&& vec) noexcept :
     ElementLinkVectorBase( std::move(vec) ),
     m_shortRefs(std::move(vec.m_shortRefs)),
     m_hostDObjs(std::move(vec.m_hostDObjs)) { }
@@ -233,7 +233,7 @@ public:
     return *this;
   }
 
-  ElementLinkVector& operator= (ElemLinkVec&& vec)
+  ElementLinkVector& operator= (ElemLinkVec&& vec) noexcept
   {
     if (this != &vec) {
       m_persKeys    = std::move(vec.m_persKeys);
@@ -416,6 +416,10 @@ private:
 
 }; // class ElementLinkVector
 
+template <typename DOBJ>
+  ElementLinkVector<DOBJ>::ElementLinkVector() : ElementLinkVectorBase() { 
+}
+
 /*
  * The following piece of code makes the Reflex dictionary think of
  * "ElementLinkVector< T, DataProxyStorage< T >,

Control/AthLinks/test/ElementLink_test.cxx

@@ -672,6 +672,9 @@ void test3 (SGTest::TestStore& store)
 
   TestStore::sgkey_t sgkey = store.stringToKey ("foocont3", fooclid);
 
+  //Add check to see if Element link optimized for std::vector expansion
+  static_assert(std::is_nothrow_move_constructible<ElementLink<FooCont>>::value);
+
   FooCont* foocont3 = new FooCont;
   for (int i=0; i < 4; i++)
     foocont3->push_back (new Foo(i+200));

Control/AthToolSupport/AsgDataHandles/AsgDataHandles/HandleKeyArray.h

+/*
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ASG_DATA_HANDLES_HANDLE_KEY_ARRAY_H
+#define ASG_DATA_HANDLES_HANDLE_KEY_ARRAY_H
+
+#ifndef XAOD_STANDALONE
+#include <StoreGate/HandleKeyArray.h>
+#else
+
+#include "AsgDataHandles/VarHandleKeyArray.h"
+
+namespace SG {
+
+  /**
+   * @class SG::HandleKeyArray<T>
+   * @brief class to hold an array of HandleKeys
+   *
+   * See StoreGate/HandleKeyArray for details.
+   *
+   * This currently (13 Aug 20) contains a number of commented out
+   * members that were part of the original handle implementation, but
+   * have not yet been implemented in the standalone version.  The plan
+   * is to either implement or remove them, depending on what is needed
+   * in AnalysisBase as we add more packages.
+   */
+
+  template <class T_Handle, class T_HandleKey/*, Gaudi::DataHandle::Mode MODE*/>
+  class HandleKeyArray : public VarHandleKeyArrayCommon< T_HandleKey > {
+  public:
+    // /**
+    //  * @brief default Constructor from a HandleKeyArray
+    //  */
+    // HandleKeyArray(){}
+
+    // /**
+    //  * @brief Constructor from a HandleKeyArray that takes a vector
+    //  * of ReadHandleKeys
+    //  * @param v vector of HandleKey
+    //  */
+    // HandleKeyArray( const std::vector<T_HandleKey>& v ) :
+    //   VarHandleKeyArrayCommon<T_HandleKey> ( v ) {}
+
+    // /**
+    //  * @brief Constructor from a HandleKeyArray that takes an 
+    //  * initializer list of HandleKeys
+    //  * @param l initializer list of HandleKey
+    //  */
+    // HandleKeyArray( std::initializer_list<T_HandleKey> l ):
+    //   VarHandleKeyArrayCommon<T_HandleKey> {l} {}
+
+    // /**
+    //  * @brief Constructor from a HandleKeyArray that takes an 
+    //  * initializer list of std::strings.
+    //  * @param l initializer list of std::strings used to create the
+    //  *          HandleKeys
+    //  */
+    // HandleKeyArray( std::initializer_list<std::string> key_names):
+    //   VarHandleKeyArrayCommon<T_HandleKey> {key_names} {}
+
+    /**
+     * @brief auto-declaring Property Constructor from a HandleKeyArray 
+     * that takes an initializer list of std::strings, and associates the WHKA
+     * with the specified Property name
+     * @param name name of Property
+     * @param l initializer list of std::strings used to create the
+     *          HandleKeys
+     * @param doc documentation string
+     */
+    template <class OWNER>
+    inline HandleKeyArray( OWNER* owner,
+                                std::string name,
+                                std::initializer_list<std::string> l,
+                                std::string doc="") :
+      VarHandleKeyArrayCommon<T_HandleKey> {l} {
+      owner->declareProperty(std::move(name), *this, std::move(doc));
+    }
+
+
+    // /**
+    //  * @brief return the type (Read/Write/Update) of handle
+    //  */
+    // Gaudi::DataHandle::Mode mode() const { return MODE; }
+
+    /**
+     * @brief create a vector of Handles from the HandleKeys
+     * in the array
+     */
+    std::vector< T_Handle > makeHandles() const {
+      std::vector< T_Handle > hndl;
+      typename std::vector<T_HandleKey>::const_iterator itr;
+      for (itr = this->begin(); itr != this->end(); ++itr) {
+        hndl.push_back ( T_Handle( *itr) );
+      }
+      return hndl;
+    }
+
+    // /**
+    //  * @brief create a vector of Handles from the HandleKeys
+    //  * in the array, with explicit EventContext.
+    //  */
+    // std::vector< T_Handle > makeHandles (const EventContext& ctx) const
+    // {
+    //   std::vector< T_Handle > hndl;
+    //   typename std::vector<T_HandleKey>::const_iterator itr;
+    //   for (itr = this->begin(); itr != this->end(); ++itr) {
+    //     hndl.push_back ( T_Handle( *itr, ctx) );
+    //   }
+    //   return hndl;
+    // }
+
+  };
+
+} // namespace SG
+
+namespace asg
+{
+  namespace detail
+  {
+    template<typename T> struct GetStringHelper;
+
+    template<typename T1,typename T2> struct GetStringHelper<SG::HandleKeyArray<T1,T2> >
+      : public GetStringHelper<std::vector<T2> >
+    {
+    };
+
+    template<typename T> struct SetStringHelper;
+
+    template<typename T1,typename T2> struct SetStringHelper<SG::HandleKeyArray<T1,T2> >
+      : public SetStringHelper<std::vector<T2> >
+    {
+    };
+  }
+}
+
+#endif
+
+#endif

Control/AthToolSupport/AsgDataHandles/AsgDataHandles/ReadHandle.h

@@ -50,12 +50,12 @@ public:
   //
 
 
-  // /**
-  //  * @brief Default constructor.
-  //  *
-  //  * The handle will not be usable until a non-blank key is assigned.
-  //  */
-  // ReadHandle();
+  /**
+   * @brief Default constructor.
+   *
+   * The handle will not be usable until a non-blank key is assigned.
+   */
+  ReadHandle() = default;
 
 
   /**
@@ -134,6 +134,14 @@ public:
   const_pointer_type get (const EventContext& ctx) const;
 
 
+  /**
+   * @brief Is the referenced object present in SG?
+   *
+   * Const method; the handle does not change as a result of this.
+   */
+  bool isPresent() const;
+
+
   /**
    * @brief Is the referenced object present in SG?
    * @param key SG key to test.

Control/AthToolSupport/AsgDataHandles/AsgDataHandles/ReadHandle.icc

@@ -174,6 +174,18 @@ ReadHandle<T>::get (const EventContext& /*ctx*/) const
 }
 
 
+/**
+* @brief Is the referenced object present in SG?
+*
+* Const method; the handle does not change as a result of this.
+*/
+template <class T>
+bool ReadHandle<T>::isPresent() const
+{
+return isPresent_impl (key());
+}
+
+
 /**
  * @brief Is the referenced object present in SG?
  * @param key SG key to test.

Control/AthToolSupport/AsgDataHandles/AsgDataHandles/ReadHandleKeyArray.h

+/*
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ASG_DATA_HANDLES_READ_HANDLE_KEY_ARRAY_H
+#define ASG_DATA_HANDLES_READ_HANDLE_KEY_ARRAY_H
+
+#ifndef XAOD_STANDALONE
+#include "StoreGate/ReadHandleKeyArray.h"
+#else
+
+#include "AsgDataHandles/HandleKeyArray.h"
+
+#include "AsgDataHandles/ReadHandleKey.h"
+#include "AsgDataHandles/ReadHandle.h"
+
+namespace SG {
+
+  /**
+   * @class SG::ReadHandleKeyArray<T>
+   * @brief class to hold an array of ReadHandleKeys
+   *
+   * See StoreGate/ReadHandleKeyArray for details.
+   *
+   * This currently (13 Aug 20) contains a commented out template
+   * argument that was part of the original handle implementation, but
+   * has not yet been implemented in the standalone version.  The plan
+   * is to either implement or remove them, depending on what is
+   * needed in AnalysisBase as we add more packages.
+   */
+  template <class T>
+  using ReadHandleKeyArray = HandleKeyArray<ReadHandle<T>, ReadHandleKey<T>/*, Gaudi::DataHandle::Reader*/ >;
+
+
+} // namespace SG
+
+#endif
+
+#endif

Control/AthToolSupport/AsgDataHandles/AsgDataHandles/VarHandleBase.h

@@ -42,6 +42,13 @@ namespace SG {
   {
   public: 
 
+    /**
+     * @brief Default constructor.
+     *
+     * The handle will not be usable until a non-blank key is assigned.
+     */
+    VarHandleBase() = default;
+
     /**
      * @brief Constructor from a VarHandleKey.
      * @param key The key object holding the clid/key/store.

Control/AthToolSupport/AsgDataHandles/AsgDataHandles/VarHandleKeyArray.h

+/*
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef ASG_DATA_HANDLES_VAR_HANDLE_KEY_ARRAY_H
+#define ASG_DATA_HANDLES_VAR_HANDLE_KEY_ARRAY_H
+
+#ifndef XAOD_STANDALONE
+#include <StoreGate/VarHandleKeyArray.h>
+#else
+
+/**
+ * @file StoreGate/VarHandleKeyArray.h
+ * @author Nils Krumnack <Nils.Erik.Krumnack@cern.h>
+ * @author C. Leggett (for original version)
+ * @brief Base class for VarHandleKeyArray for reading from StoreGate.
+ */
+
+#include <AsgMessaging/StatusCode.h>
+#include <vector>
+#include <string>
+
+namespace SG {
+
+  /**
+   * @class SG::VarHandleKeyArray<T>
+   * @brief untemplated base class for VarHandleKeyArrays
+   *
+   * See StoreGate/VarHandleKeyArray for details.
+   *
+   * This currently (13 Aug 20) contains a number of commented out
+   * members that were part of the original handle implementation, but
+   * have not yet been implemented in the standalone version.  The plan
+   * is to either implement or remove them, depending on what is needed
+   * in AnalysisBase as we add more packages.
+   */
+  class VarHandleKeyArray {
+  public:
+    VarHandleKeyArray(){};
+    virtual ~VarHandleKeyArray() = default;
+    // virtual StatusCode assign(const std::vector<std::string>& vs)=0;
+    virtual std::string toString() const = 0;
+    // virtual Gaudi::DataHandle::Mode mode() const = 0;
+
+    // virtual std::vector<SG::VarHandleKey*> keys() const = 0;
+
+    // virtual void renounce() = 0;
+    // virtual bool renounced() const = 0;
+    // virtual void declare(IDataHandleHolder*)  = 0;
+
+    // virtual void setOwner( IDataHandleHolder* o ) = 0;
+    // virtual const IDataHandleHolder* owner() const = 0;
+    // virtual IDataHandleHolder* owner() = 0;
+
+  };
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+// mixin class for common functionality
+//
+
+  /**
+   * @class SG::VarHandleKeyArrayCommon<T>
+   * @brief mixin base class for VarHandleKeyArrays, inheriting from
+   * std::vector as well as VarHandleKeyArray to provide vector-like
+   * access
+   *
+   * See StoreGate/VarHandleKeyArrayCommon for details.
+   *
+   * This currently (13 Aug 20) contains a number of commented out
+   * members that were part of the original handle implementation, but
+   * have not yet been implemented in the standalone version.  The plan
+   * is to either implement or remove them, depending on what is needed
+   * in AnalysisBase as we add more packages.
+   *
+   */
+
+  template <class Base>
+  class VarHandleKeyArrayCommon : public VarHandleKeyArray, 
+                                  public std::vector<Base> {
+  public:
+    /**
+     * @brief default base Constructor of mixin
+     *
+     */
+    VarHandleKeyArrayCommon() : std::vector<Base>() {};
+    
+    /**
+     * @brief base Constructor from a VarHandleKeyArray that takes a vector
+     * @param v vector of Read/Write/UpdateHandleKey
+     */
+    VarHandleKeyArrayCommon( const std::vector<Base>& v ):
+      std::vector<Base>(v) {};
+    
+    /**
+     * @brief base Constructor from a VarHandleKeyArray that takes an 
+     * initializer list of VarHandleKeys
+     * @param l initializer list of Read/Write/UpdateHandleKey
+     */
+    VarHandleKeyArrayCommon( std::initializer_list<Base> l ):
+      std::vector<Base>{l} {};
+    
+    /**
+     * @brief base Constructor from a VarHandleKeyArray that takes an 
+     * initializer list of std::strings.
+     * @param l initializer list of std::strings used to create the
+     *          VarHandleKeys
+     */
+    VarHandleKeyArrayCommon( std::initializer_list<std::string> l ) {
+      for (auto &e : l) {
+        this->push_back( Base{e} );
+      }
+    }    
+    
+    /**
+     * @brief forward the initialization to the member VarHandleKeys
+     * @param used If false, then this handle is not to be used.
+     *             Instead of normal initialization, the key will be cleared.
+     */
+    StatusCode initialize (bool used = true);
+
+    // /**
+    //  * @brief Set the contents of the VarHandleKeyArray from a 
+    //  * vector of std::strings
+    //  * @param vs vector of initializer strings
+    //  */
+    // virtual StatusCode assign(const std::vector<std::string>& vs) override;
+
+    /**
+     * @brief string representation of the VarHandleKeyArray
+     */
+    virtual std::string toString() const override;
+
+    // /**
+    //  * @brief create array of all base VarHandleKeys in the Array
+    //  */
+    // virtual std::vector<SG::VarHandleKey*> keys() const override;
+    
+
+    // /**
+    //  * @brief if called, handles will not be declared in the algorithm I/O
+    //  */
+    // virtual void renounce() override { m_isRenounced = true; }
+    
+    // /**
+    //  * @brief query renounced state
+    //  **/ 
+    // virtual bool renounced() const override { return m_isRenounced; }
+
+    // virtual void declare( IDataHandleHolder* ) override;
+
+    // virtual void setOwner( IDataHandleHolder* o ) override { m_owner = o; }
+    // virtual const IDataHandleHolder* owner() const override { return m_owner; }
+    // virtual IDataHandleHolder* owner() override { return m_owner; }
+
+  private:
+    
+    // bool m_isRenounced{ false };
+    // IDataHandleHolder* m_owner{ nullptr };
+
+  };
+  
+} // namespace SG
+
+namespace std {
+  ostream& operator<<(ostream& s, const SG::VarHandleKeyArray& m);
+}
+
+
+#include "AsgDataHandles/VarHandleKeyArray.icc"
+
+#endif
+
+#endif

Control/AthToolSupport/AsgDataHandles/AsgDataHandles/VarHandleKeyArray.icc

+/*
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+#include <sstream>
+
+
+namespace SG {
+  /**
+   * @brief forward the initialization to the member VarHandleKeys
+   * @param used If false, then this handle is not to be used.
+   *             Instead of normal initialization, the key will be cleared.
+   */
+  template <class Base>
+  inline
+  StatusCode VarHandleKeyArrayCommon<Base>::initialize (bool used /*= true*/) {
+    StatusCode sc(StatusCode::SUCCESS);
+    if (used) {
+      // IDataHandleHolder* const owner = this->owner();
+      for (Base& b : *this) {
+        // if (owner != nullptr) {
+        //   b.setOwner(owner);
+        // }
+        if ( b.initialize().isFailure() ) {
+          sc = StatusCode::FAILURE;
+        }
+      }
+    }
+    else {
+      this->clear();
+    }
+    return sc;
+  }
+
+  // //
+  // // Set the VarHandleKey from a string
+  // //
+  // template <class Base>
+  // inline
+  // StatusCode VarHandleKeyArrayCommon<Base>::assign(const std::vector<std::string>& vs) {
+  //   StatusCode sc(StatusCode::SUCCESS);
+  //   this->clear();
+  //   for (auto & s : vs) {
+  //     Base b;
+  //     if (!b.assign(s)) {
+  //       sc = StatusCode::FAILURE;
+  //     } else {
+  //       // Skip blank keys
+  //       if (b.key() != "") {
+  //         this->push_back(b);
+  //       }
+  //     }
+  //   }
+  //   return sc;
+  // }
+  
+  //
+  // string representation of VarHandleKeyArray
+  //
+  template <class Base>
+  inline
+  std::string VarHandleKeyArrayCommon<Base>::toString() const {
+    std::ostringstream ost;
+    typename std::vector<Base>::const_iterator itr;
+    itr = this->begin();
+    size_t sz = this->size();
+    for ( size_t i=0; i < sz; ++i, ++itr) {
+      // ost << "'" << itr->objKey() << "'";
+      ost << "'" << itr->key() << "'";
+      if (i != sz-1) {
+        ost << ",";
+      }
+    }
+    return ost.str();      
+  }
+  
+  // //
+  // // create array of all base VarHandleKeys in the Array
+  // //
+  // template <class Base>
+  // inline  
+  // std::vector<SG::VarHandleKey*> VarHandleKeyArrayCommon<Base>::keys() const {
+  //   std::vector<SG::VarHandleKey*> keys;
+  //   for (const SG::VarHandleKey& k : *this) {
+  //     // FIXME: This is a rule violation, but we can't really fix it without
+  //     // changing the IDataHandleHolder base class from Gaudi.
+  //     SG::VarHandleKey* k_nc ATLAS_THREAD_SAFE = const_cast<SG::VarHandleKey*>(&k);
+  //     keys.push_back (k_nc);
+  //   }
+  //   return keys;
+  // }      
+ 
+  // template <class Base>
+  // inline  
+  // void VarHandleKeyArrayCommon<Base>::declare(IDataHandleHolder* owner) {
+  //   if ( renounced() ) {
+  //     return;
+  //   }     
+  //   for (auto k: keys() ) {
+  //     owner->declare ( *k );
+  //     k->setOwner( owner );
+  //   }
+  // }
+}

Control/AthToolSupport/AsgDataHandles/AsgDataHandles/WriteHandle.h

@@ -141,11 +141,11 @@ public:
   // pointer_type operator->();
 
 
-  // /**
-  //  * @brief Dereference the pointer.
-  //  * Returns the cached pointer.  Throws ExcNullWriteHandle if null.
-  //  */
-  // reference_type operator*();
+  /**
+   * @brief Dereference the pointer.
+   * Returns the cached pointer.  Throws ExcNullWriteHandle if null.
+   */
+  reference_type operator*();
 
 
   // /**
@@ -168,10 +168,10 @@ public:
   // pointer_type cachedPtr();
 
 
-  // /**
-  //  * @brief Can the handle be successfully dereferenced?
-  //  */
-  // virtual bool isValid() override final;
+  /**
+   * @brief Can the handle be successfully dereferenced?
+   */
+  bool isValid();
 
 
   //************************************************************************
@@ -179,11 +179,11 @@ public:
   //
 
 
-  // /**
-  //  * @brief Record a const object to the store.
-  //  * @param data The object to record.
-  //  */
-  // StatusCode record (std::unique_ptr<T> data);
+  /**
+   * @brief Record a const object to the store.
+   * @param data The object to record.
+   */
+  StatusCode record (std::unique_ptr<T> data);
 
 
   // /**
@@ -231,22 +231,22 @@ public:
   // StatusCode recordNonConst (SG::DataObjectSharedPtr<T> data);
 
 
-  // /**
-  //  * @brief Record an object to the store.
-  //  * @param data The object to record.
-  //  * @param returnExisting Allow an existing object?
-  //  *
-  //  * Unlike record(), this does not change the handle object.
-  //  * That means that one will not be able to get the object back
-  //  * by dereferencing the handle.
-  //  * Returns the object placed in the store, or nullptr if there
-  //  * was an error.
-  //  * If there was already an object in the store with the given key,
-  //  * then return null, unless @c returnExisting is true, in which case
-  //  * return success.  In either case, @c data is destroyed.
-  //  */
-  // const_pointer_type put (std::unique_ptr<T> data,
-  //                         bool returnExisting = false) const;
+  /**
+   * @brief Record an object to the store.
+   * @param data The object to record.
+   * @param returnExisting Allow an existing object?
+   *
+   * Unlike record(), this does not change the handle object.
+   * That means that one will not be able to get the object back
+   * by dereferencing the handle.
+   * Returns the object placed in the store, or nullptr if there
+   * was an error.
+   * If there was already an object in the store with the given key,
+   * then return null, unless @c returnExisting is true, in which case
+   * return success.  In either case, @c data is destroyed.
+   */
+  const_pointer_type put (std::unique_ptr<T> data/*,
+                          bool returnExisting = false*/) const;
 
 
   // /**
@@ -630,6 +630,9 @@ private:
   // /// set it const on the record, but instead set this and do the
   // /// setConst in the destructor.
   // SG::DataProxy* m_lockAuxPending = nullptr;
+
+  /// the cached pointer we recorded
+  T *m_ptr {nullptr};
 }; 
 
 

Control/AthToolSupport/AsgDataHandles/AsgDataHandles/WriteHandle.icc

@@ -171,17 +171,19 @@ WriteHandle<T>::~WriteHandle()
 // }
 
 
-// /**
-//  * @brief Dereference the pointer.
-//  * Returns the cached pointer.  Throws ExcNullWriteHandle if null.
-//  */
-// template <class T>
-// inline
-// typename WriteHandle<T>::reference_type
-// WriteHandle<T>::operator*()
-// {
-//   return *WriteHandle<T>::checkedCachedPtr();
-// }
+/**
+ * @brief Dereference the pointer.
+ * Returns the cached pointer.  Throws ExcNullWriteHandle if null.
+ */
+template <class T>
+inline
+typename WriteHandle<T>::reference_type
+WriteHandle<T>::operator*()
+{
+  if (m_ptr == nullptr)
+    throw std::runtime_error ("dereferenced handle is null: " + key());
+  return *m_ptr;
+}
 
 
 // /**
@@ -222,32 +224,35 @@ WriteHandle<T>::~WriteHandle()
 // }
 
 
-// /**
-//  * @brief Can the handle be successfully dereferenced?
-//  */
-// template <class T>
-// inline
-// bool WriteHandle<T>::isValid()
-// {
-//   return this->m_ptr != nullptr;
-// }
+/**
+ * @brief Can the handle be successfully dereferenced?
+ */
+template <class T>
+inline
+bool WriteHandle<T>::isValid()
+{
+  return this->m_ptr != nullptr;
+}
 
 
 //************************************************************************
 // Record.
 
 
-// /**
-//  * @brief Record a const object to the store.
-//  * @param data The object to record.
-//  */
-// template <class T>
-// inline
-// StatusCode
-// WriteHandle<T>::WriteHandle::record (std::unique_ptr<T> data)
-// {
-//   return this->doRecord (std::move(data), true, false);
-// }
+/**
+ * @brief Record a const object to the store.
+ * @param data The object to record.
+ */
+template <class T>
+inline
+StatusCode
+WriteHandle<T>::WriteHandle::record (std::unique_ptr<T> data)
+{
+  m_ptr = data.get();
+  if (xAOD::TActiveStore::store()->record (std::move (data), key()).isFailure())
+    return StatusCode::FAILURE;
+  return StatusCode::SUCCESS;
+}
 
 
 // /**
@@ -276,6 +281,7 @@ StatusCode
 WriteHandle<T>::WriteHandle::record (std::unique_ptr<T> data,
                                      std::unique_ptr<AUXSTORE> auxstore)
 {
+  m_ptr = data.get();
   if (xAOD::TActiveStore::store()->record (std::move (auxstore), key() + "Aux.").isFailure())
     return StatusCode::FAILURE;
   if (xAOD::TActiveStore::store()->record (std::move (data), key()).isFailure())
@@ -330,29 +336,31 @@ WriteHandle<T>::WriteHandle::record (std::unique_ptr<T> data,
 // }
 
 
-// /**
-//  * @brief Record an object to the store.
-//  * @param data The object to record.
-//  * @param returnExisting Allow an existing object?
-//  *
-//  * Unlike record(), this does not change the handle object.
-//  * That means that one will not be able to get the object back
-//  * by dereferencing the handle.
-//  * Returns the object placed in the store, or nullptr if there
-//  * was an error.
-//  * If there was already an object in the store with the given key,
-//  * then return null, unless @c returnExisting is true, in which case
-//  * return success.  In either case, @c data is destroyed.
-//  */
-// template <class T>
-// inline
-// typename WriteHandle<T>::const_pointer_type
-// WriteHandle<T>::put (std::unique_ptr<T> data,
-//                      bool returnExisting /*= false*/) const
-// {
-//   IProxyDict* store = nullptr;
-//   return doPut (nullptr, std::move(data), returnExisting, store);
-// }
+/**
+ * @brief Record an object to the store.
+ * @param data The object to record.
+ * @param returnExisting Allow an existing object?
+ *
+ * Unlike record(), this does not change the handle object.
+ * That means that one will not be able to get the object back
+ * by dereferencing the handle.
+ * Returns the object placed in the store, or nullptr if there
+ * was an error.
+ * If there was already an object in the store with the given key,
+ * then return null, unless @c returnExisting is true, in which case
+ * return success.  In either case, @c data is destroyed.
+ */
+template <class T>
+inline
+typename WriteHandle<T>::const_pointer_type
+WriteHandle<T>::put (std::unique_ptr<T> data/*,
+                     bool returnExisting / *= false*/) const
+{
+  const_pointer_type result = data.get();
+  if (xAOD::TActiveStore::store()->record (std::move (data), key()).isFailure())
+    throw std::runtime_error ("failed to record object: " + key());
+  return result;
+}
 
 
 // /**

Control/AthToolSupport/AsgDataHandles/Root/VarHandleKeyArray.cxx

+/*
+  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifdef XAOD_STANDALONE
+
+#include "AsgDataHandles/VarHandleKeyArray.h"
+
+// namespace Gaudi { 
+//   namespace Parsers {
+    
+    
+// /**
+//  * @brief Gaudi function used to initialize a property from a string.
+//  * @param v The object to initialize.
+//  * @param s The string from which to initialize.
+//  *
+//  * Used during Gaudi property handling to set object @c v from the string @c s.
+//  * Note that @c s is a representation of the property setting; thus, in the
+//  * case of setting a property from a string, @c s will contain quote marks.
+//  */
+//     StatusCode 
+//     GAUDI_API
+//     parse(SG::VarHandleKeyArray& v, const std::string& s)
+//     {
+//       std::vector<std::string> vp;
+//       StatusCode sc = Gaudi::Parsers::parse(vp, s);
+      
+//       if (sc.isSuccess())
+//         sc = v.assign( vp );
+      
+//       return sc;
+//     }
+    
+//   } //> ns Parsers
+
+//   namespace Utils {
+    
+    
+// /**
+//  * @brief Gaudi function used to convert a property to a string.
+//  * @param v The object to convert.
+//  * @param o Stream to which to do the conversion.
+//  *
+//  * Used during Gaudi property handling to get a string representation of @c v.
+//  * Note that if the representation is a string, it should be surrounded
+//  * by quote marks.
+//  */
+//     std::ostream& 
+//     GAUDI_API
+//     toStream(const SG::VarHandleKeyArray& v, std::ostream& o)
+//     {
+//       o << "[" << v.toString() << "]";      
+//       return o;
+//     }
+    
+//   } //> ns Utils
+// } //> ns Gaudi
+
+
+
+
+namespace std {
+  ostream& operator<<(ostream& s, const SG::VarHandleKeyArray& m) {
+    s << "[" <<  m.toString() << "]";
+    return s;
+  }
+}
+
+#endif

Control/AthToolSupport/AsgExampleTools/AsgExampleTools/DataHandleTestTool.h

@@ -12,6 +12,7 @@
 #include <AsgTools/AsgTool.h>
 #include <AsgExampleTools/IDataHandleTestTool.h>
 #include <AsgDataHandles/ReadHandleKey.h>
+#include <AsgDataHandles/ReadHandleKeyArray.h>
 #include <AsgDataHandles/ReadDecorHandleKey.h>
 #include <AsgDataHandles/WriteHandleKey.h>
 
@@ -52,9 +53,11 @@ namespace asg
 #ifndef SIMULATIONBASE
     SG::ReadHandleKey<xAOD::MuonContainer> m_readKey {this, "readKey", "Muons", "regular read key"};
     SG::ReadDecorHandleKey<xAOD::MuonContainer> m_readDecorKey {this, "readDecorKey", "Muons.pt", "read decor key"};
+    SG::ReadHandleKeyArray<xAOD::MuonContainer> m_readKeyArray {this, "readKeyArray", {}, "array read key"};
     SG::WriteHandleKey<xAOD::MuonContainer> m_writeKey {this, "writeKey", "", "regular write key"};
 #endif
     bool m_readFailure {false};
+    bool m_readArray {false};
     bool m_readDecorFailure {false};
     std::string m_doWriteName;
   };

Control/AthToolSupport/AsgExampleTools/Root/DataHandleTestTool.cxx

@@ -35,6 +35,7 @@ namespace asg
   {
     declareProperty ("readFailure", m_readFailure, "whether to expect a read failure");
     declareProperty ("readDecorFailure", m_readDecorFailure, "whether to expect a read decoration failure");
+    declareProperty ("readArray", m_readArray, "whether to read from the array");
     declareProperty ("doWriteName", m_doWriteName, "if we should write, the name we expect to write to");
   }
 
@@ -55,6 +56,7 @@ namespace asg
     ANA_CHECK (m_readDecorKey.initialize ());
     if (!m_writeKey.empty())
       ANA_CHECK (m_writeKey.initialize ());
+    ANA_CHECK (m_readKeyArray.initialize());
 #endif
     return StatusCode::SUCCESS;
   }
@@ -73,10 +75,12 @@ namespace asg
     auto readHandle = makeHandle (m_readKey);
     if (m_readFailure == true)
     {
+      EXPECT_FALSE (readHandle.isPresent());
       EXPECT_EQ (nullptr, readHandle.get());
       EXPECT_FALSE (readHandle.isValid());
     } else
     {
+      EXPECT_TRUE (readHandle.isPresent());
       EXPECT_EQ (muonsStore, readHandle.get());
       EXPECT_TRUE (readHandle.isValid());
     }
@@ -91,6 +95,16 @@ namespace asg
       EXPECT_EQ (acc (*testMuon), readDecorHandle (*testMuon));
     }
 
+    if (m_readArray)
+    {
+      EXPECT_EQ (1u, m_readKeyArray.size());
+      auto handles = m_readKeyArray.makeHandles();
+      EXPECT_EQ (muonsStore, handles[0].get());
+    } else
+    {
+      EXPECT_EQ (0u, m_readKeyArray.size());
+    }
+
     if (!m_doWriteName.empty())
     {
       auto writeHandle = makeHandle (m_writeKey);