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

#include <CopyHelpers.h>

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

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, 1 >

Definition at line 67 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, 1 >::StoreType

the type of the event store we use

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

Member Function Documentation

getCopy()

template<typename T >

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

inlinestatic

Definition at line 75 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() ) );
              }
              // Set the origin links on it. Note that
              // xAOD::setOriginalObjectLink's "container version" doesn't work
              // with view containers, we have to call this function one-by-one
              // on the elements.
              for( size_t i = 0; i < inputObject->size(); ++i ) {
                 if( ! xAOD::setOriginalObjectLink( *( ( *inputObject )[ i ] ),
                                                    *( ( *viewCopy )[ i ] ) ) ) {
                    return StatusCode::FAILURE;
                 }
              }
              // 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;
           }
 
           if (!xAOD::setOriginalObjectLink (*inputObject, *copy.first)) {
              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