ShallowCopy.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef XAODCORE_SHALLOWCOPY_H
#define XAODCORE_SHALLOWCOPY_H
 
// System include(s):
#include <map>
#include <iostream>
 
// EDM include(s):
#include "AthLinks/DataLink.h"
#include "AthContainersInterfaces/IConstAuxStore.h"
#include "AthContainers/CurrentContext.h"
#include "AthContainers/tools/AuxElementConcepts.h"
#include "AthContainers/tools/DataVectorConcepts.h"
 
// Local include(s):
#include "xAODCore/ShallowAuxContainer.h"
#include "xAODCore/ShallowAuxInfo.h"
 
 
 
namespace xAOD {

 
  template< class T >
  std::unique_ptr<T> prepareElementForShallowCopy(const T* /*elem*/) {
    return std::make_unique<T>();
  }

  template <class T>
    requires SG::IsAuxDataVector<T> || SG::IsConstAuxElement<T>
  struct ShallowCopyResult {};

  template <SG::IsAuxDataVector T>
  struct ShallowCopyResult<T> {
    using type =
        std::pair<std::unique_ptr<T>, std::unique_ptr<ShallowAuxContainer>>;
  };

  template <SG::IsConstAuxElement T>
  struct ShallowCopyResult<T> {
    using type = std::pair<std::unique_ptr<T>, std::unique_ptr<ShallowAuxInfo>>;
  };

  template <class T>
  using ShallowCopyResult_t = typename ShallowCopyResult<T>::type;

  template <SG::IsAuxDataVector T>
  ShallowCopyResult_t<T> shallowCopy(const T& cont, const EventContext& ctx);

  template <SG::IsAuxDataVector T>
  ShallowCopyResult_t<T> shallowCopy(const T& cont);

  template <SG::IsConstAuxElement T>
  ShallowCopyResult_t<T> shallowCopy(const T& obj, const EventContext& ctx);

  template <SG::IsConstAuxElement T>
  ShallowCopyResult_t<T> shallowCopy(const T& obj);
 
  namespace detail{
  template<class T>
  std::pair<std::unique_ptr<T>, std::unique_ptr<ShallowAuxContainer>>
  shallowCopyContainerImpl(const T& cont,
                           DataLink<SG::IConstAuxStore>& link){
 
    if (!link.cptr()) {
      // This can happen when we read the input file in standalone
      // mode in branch access mode. That's unfortunately not
      // compatible with using a shallow copy auxiliary store.
      std::cout << "xAOD::shallowCopyContainer ERROR Couldn't set up "
                << "DataLink to the original container's auxiliary store"
                << std::endl;
      std::cout << "xAOD::shallowCopyContainer ERROR Are you using the "
                << "xAOD::TEvent::kBranchAccess access mode?" << std::endl;
      return {};
    }
 
    // Create the new DV container:
    auto newCont = std::make_unique<T>();
 
    // Add the required number of elements to it:
    newCont->reserve(cont.size());
    for (size_t i = 0; i < cont.size(); ++i) {
      newCont->push_back(prepareElementForShallowCopy(cont[i]));
    }
 
    // Create a new shallow auxiliary container:
    auto aux = std::make_unique<ShallowAuxContainer>(link);
 
    // Connect it to the interface container:
    newCont->setStore(aux.get());
 
    // Return the new objects:
    return std::make_pair(std::move(newCont), std::move(aux));
  }
  }//end namespace detail

 
  template<class T>
  std::pair<std::unique_ptr<T>, std::unique_ptr<ShallowAuxContainer>>
  shallowCopyContainer(const T& cont,
                       const EventContext& ctx )
  {
    DataLink<SG::IConstAuxStore> link (cont.getConstStore(), ctx);
    return detail::shallowCopyContainerImpl(cont,link);
  }

   //
   template< class T >
   [[deprecated("Please switch to xAOD::shallowCopy(...), which returns unique_ptr")]]
   std::pair< T*, ShallowAuxContainer* > shallowCopyContainer( const T& cont ) {
     DataLink<SG::IConstAuxStore> link (cont.getConstStore());
     auto tmp = detail::shallowCopyContainerImpl(cont, link);
     return std::make_pair(tmp.first.release(), tmp.second.release());
   }

   template< class T >
   std::pair< std::unique_ptr<T>, std::unique_ptr<ShallowAuxInfo> >
   shallowCopyObject( const T& obj, const EventContext& ctx ) {
 
      // Create a DataLink, to check if we'll be successful:
      DataLink< SG::IConstAuxStore > link( obj.getConstStore(), ctx );
      if( ! link.cptr() ) {
         // This can happen when we read the input file in standalone
         // mode in branch access mode. That's unfortunately not
         // compatible with using a shallow copy auxiliary store.
         std::cout << "xAOD::shallowCopyObject ERROR Couldn't set up "
                   << "DataLink to the original object's auxiliary store"
                   << std::endl;
         std::cout << "xAOD::shallowCopyObject ERROR Are you using the "
                   << "xAOD::TEvent::kBranchAccess access mode?"
                   << std::endl;
         std::pair< std::unique_ptr<T>, std::unique_ptr<ShallowAuxInfo> > dummy;
         return dummy;
      }
 
      // Create a new object using its default constructor:
      auto newObj = std::make_unique<T>();
 
      // Create a new shallow auxiliary store:
      auto aux = std::make_unique<ShallowAuxInfo>( link );
 
      // Connect it to the interface object:
      newObj->setStore( aux.get() );
 
      // Return the new objects:
      return std::make_pair( std::move(newObj), std::move(aux) );
   }
 
   // Backwards compatibility
   template< class T >
   [[deprecated("Please switch to xAOD::shallowCopy(...), which returns unique_ptr")]]
   std::pair< T*, ShallowAuxInfo* >
   shallowCopyObject( const T& obj ) {
     auto ptrs =  shallowCopyObject (obj, Gaudi::Hive::currentContext());
     return std::make_pair (ptrs.first.release(), ptrs.second.release());
   }
 
} // namespace xAOD
 
// Include the implementation.
#include "xAODCore/ShallowCopy.icc"
 
#endif // XAODCORE_SHALLOWCOPY_H