ShallowCopy.h

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
// $Id: ShallowCopy.h 766390 2016-08-04 11:18:59Z wlampl $
#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"
 
// Local include(s):
#include "xAODCore/ShallowAuxContainer.h"
#include "xAODCore/ShallowAuxInfo.h"
 
#ifndef XAOD_STANDALONE
#include <GaudiKernel/ThreadLocalContext.h>
#else
class EventContext;
#endif
 
 
namespace xAOD {

 
  template< class T >
  std::unique_ptr<T> prepareElementForShallowCopy(const T* /*elem*/) {
    return std::make_unique<T>();
  }
 
  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,
                       [[maybe_unused]] const EventContext& ctx
  ){
#ifndef XAOD_STANDALONE
    DataLink<SG::IConstAuxStore> link (cont.getConstStore(), ctx);
#else
    //Note that in AnalysisBase
    //- EventContext, is not a complete type, we have no class.
    //- We do not have a DataLink ctor with EventContext
    //- The return value of currentContext() can not be used.
    DataLink<SG::IConstAuxStore> link(cont.getConstStore());
#endif
    return detail::shallowCopyContainerImpl(cont,link);
  }

   //
   template< class T >
   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< T*, ShallowAuxInfo* > shallowCopyObject( const T& obj ) {
 
      // Create a DataLink, to check if we'll be successful:
      DataLink< SG::IConstAuxStore > link( obj.getConstStore() );
      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< T*, ShallowAuxInfo* > dummy;
         return dummy;
      }
 
      // Create a new object using its default constructor:
      T* newObj = new T();
 
      // Create a new shallow auxiliary store:
      ShallowAuxInfo* aux = new ShallowAuxInfo( link );
 
      // Connect it to the interface object:
      newObj->setStore( aux );
 
      // Return the new objects:
      return std::make_pair( newObj, aux );
   }
 
} // namespace xAOD
 
#endif // XAODCORE_SHALLOWCOPY_H