/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/xAODCore/xAODCore/ShallowCopy.h

// Dear emacs, this is -*- c++ -*-
// $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>

//Core includes
#include "CxxUtils/make_unique.h"

// EDM include(s):
#include "AthLinks/DataLink.h"
#include "AthContainersInterfaces/IConstAuxStore.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 CxxUtils::make_unique<T>();
  }


   template< class T >
   std::pair< T*, ShallowAuxContainer* > shallowCopyContainer( const T& cont ) {

      // Create a DataLink, to check if we'll be successful:
      DataLink< SG::IConstAuxStore > link( cont.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::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;
         std::pair< T*, ShallowAuxContainer* > dummy;
         return dummy;
      }

      // Create the new DV container:
      T* newCont = new 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:
      ShallowAuxContainer* aux = new ShallowAuxContainer( link );

      // Connect it to the interface container:
      newCont->setStore( aux );

      // Return the new objects:
      return std::make_pair( newCont, aux );
   }

   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

---