CP::detail::ShallowCopy< T, 2 > Struct Template Reference

#include <CopyHelpers.h>

Collaboration diagram for CP::detail::ShallowCopy< T, 2 >:

Public Types
typedef std::decay< decltype(*(std::declval< EL::AnaAlgorithm >).evtStore()))>::type	StoreType
	the type of the event store we use More...

Static Public Member Functions
static StatusCode	getCopy (MsgStream &msgStream, StoreType &store, T *&object, const T *inputObject, const std::string &outputName, const std::string &auxName)

Detailed Description

template<typename T>
struct CP::detail::ShallowCopy< T, 2 >

Definition at line 177 of file SystematicsHandles/SystematicsHandles/CopyHelpers.h.

Member Typedef Documentation

StoreType

template<typename T >

typedef std::decay<decltype( *(std::declval<EL::AnaAlgorithm>).evtStore()))>::type CP::detail::ShallowCopy< T, 2 >::StoreType

the type of the event store we use

Definition at line 182 of file SystematicsHandles/SystematicsHandles/CopyHelpers.h.

Member Function Documentation

getCopy()

template<typename T >

static StatusCode CP::detail::ShallowCopy< T, 2 >::getCopy ( MsgStream &  msgStream, StoreType &  store, T *&  object, const T *  inputObject, const std::string &  outputName, const std::string &  auxName  )

inlinestatic

Definition at line 185 of file SystematicsHandles/SystematicsHandles/CopyHelpers.h.

      {
         // Define the msg(...) function as a lambda.
         // Suppress thread-checker warning because this provides just a wrapper to MsgStream.
         const auto msg = [&] ATLAS_NOT_THREAD_SAFE (MSG::Level lvl) -> MsgStream& {
            msgStream << lvl;
            return msgStream;
         };
 
         // Make sure that we get a valid pointer.
         assert (inputObject != nullptr);
 
         // Handle the case when the input object is a view container.
         if( ! inputObject->getConstStore() ) {
 
            // Decide how to handle the container.
            if( inputObject->size() ) {
               // Get the pointer to the "owning container" from the first
               // element.
               const T* originContainer =
                 dynamic_cast< const T* >( ( *inputObject )[ 0 ]->container() );
               // Make sure that every element in the view container has the same
               // parent.
               for( size_t i = 1; i < inputObject->size(); ++i ) {
                  if( ( *inputObject )[ i ]->container() != originContainer ) {
                     ANA_MSG_ERROR( "Not all elements of the received view "
                                    "container come from the same container!" );
                     return StatusCode::FAILURE;
                  }
               }
               // Postfix for the shallow-copy container of the origin container.
               static const char* const ORIGIN_POSTFIX = "_ShallowCopyOrigin";
               // Make a shallow copy of the origin container.
               auto originCopy = xAOD::shallowCopyContainer( *originContainer );
               if( ( ! originCopy.first ) || ( ! originCopy.second ) ) {
                  ANA_MSG_ERROR( "Failed to shallow copy the origin of a view "
                                 << "container, meant for: " << outputName );
                  return StatusCode::FAILURE;
               }
               // ...and record it.
               ANA_CHECK( store.record( originCopy.first,
                                        outputName + ORIGIN_POSTFIX ) );
               ANA_CHECK( store.record( originCopy.second,
                                        outputName + ORIGIN_POSTFIX +
                                        "Aux." ) );
               // Make a view copy on top of it.
               auto viewCopy = std::make_unique< T >( SG::VIEW_ELEMENTS );
               auto viewCopyPtr = viewCopy.get();
               for( const auto* element : *inputObject ) {
                  viewCopy->push_back( originCopy.first->at( element->index() ) );
               }
               // Finally, record the view container with the requested name.
               ANA_CHECK( store.record( viewCopy.release(), outputName ) );
               // The copy is done.
               object = viewCopyPtr;
               return StatusCode::SUCCESS;
            } else {
               // If the container was empty, then let's just make a new empty
               // container, and that's that...
               auto viewCopy = std::make_unique< T >( SG::VIEW_ELEMENTS );
               auto viewCopyPtr = viewCopy.get();
               ANA_CHECK( store.record( viewCopy.release(), outputName ) );
               // The copy is done.
               object = viewCopyPtr;
               return StatusCode::SUCCESS;
              }
 
         } else {
 
            // We can just copy the container as is.
            auto copy = xAOD::shallowCopyContainer( *inputObject );
            if (!copy.first || !copy.second)
            {
               ANA_MSG_ERROR ("failed to shallow copy object: " << outputName);
               ANA_MSG_ERROR ("likely shallow copying a view container");
               return StatusCode::FAILURE;
            }
 
            ANA_CHECK (store.record (copy.second, auxName));
            ANA_CHECK (store.record (copy.first, outputName));
            object = copy.first;
            return StatusCode::SUCCESS;
         }
      }

---

The documentation for this struct was generated from the following file:

• SystematicsHandles/SystematicsHandles/CopyHelpers.h