TAuxVector.cxx

Go to the documentation of this file.

// Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
 
// ROOT include(s):
#include <TClass.h>
#include <TVirtualCollectionProxy.h>
#include <TError.h>
 
// EDM include(s):
#include "AthContainersInterfaces/IAuxTypeVectorFactory.h"
#include "AthContainers/AuxVectorData.h"
#include "AthContainers/tools/AuxVectorInterface.h"
 
// Local include(s):
#include "xAODRootAccess/tools/TAuxVector.h"
#include "xAODRootAccess/tools/TAuxVectorFactory.h"
#include "xAODRootAccess/tools/Message.h"
 
namespace xAOD {
 
   TAuxVector::TAuxVector( const TAuxVectorFactory* factory,
                           SG::auxid_t auxid,
                           const ::TClass* cl, size_t size, size_t,
                           bool isLinked )
      : IAuxTypeVector( auxid, isLinked ),
        m_factory( factory ),
        m_proxy( cl->GetCollectionProxy()->Generate() ), m_vec( cl->New() ) {
 
      // A little sanity check:
      if( ! m_proxy ) {
         ::Fatal( "xAOD::TAuxVector::TAuxVector",
                  XAOD_MESSAGE( "No collection proxy found for type %s" ),
                  cl->GetName() );
      }
      else {
         m_proxy->PushProxy( m_vec );
      }
 
      // Make sure the object is of the right size:
      this->resize( size );
   }
 
   TAuxVector::TAuxVector( const TAuxVector& parent )
      : IAuxTypeVector( parent ),
        m_factory( parent.m_factory ), m_proxy( parent.m_proxy->Generate() ),
        m_vec( parent.m_proxy->GetCollectionClass()->New() ) {
 
      m_proxy->PushProxy( m_vec );
 
      // Check the size of the parent object:
      const size_t size = parent.size();
      // Check if we need to do anything:
      if( ! size ) {
         return;
      }
 
      // First off, resize this vector:
      this->resize( size );
 
      // Get a pointer to the start of the parent's payload:
      const void* parentPtr = parent.toPtr();
 
      // Do the copy:
      this->copyRange( parentPtr, this->toPtr(), size );
   }
 
   TAuxVector::~TAuxVector() {
 
      m_proxy->Destructor( m_vec );
   }
 
   TAuxVector& TAuxVector::operator= ( const TAuxVector& other ) {
 
      // Check if anything needs to be done:
      if( this == &other ) {
         return *this;
      }
 
      // Clean out the previous payload:
      m_proxy->Destructor( m_vec );
 
      // Get the information from the other object:
      IAuxTypeVector::operator=( other );
      m_factory = other.m_factory;
      m_proxy.reset( other.m_proxy->Generate() );
 
      // Create a new vector:
      m_vec = m_proxy->GetCollectionClass()->New();
      m_proxy->PushProxy( m_vec );
 
      IAuxTypeVector::resetDataSpan();
 
      // Check the size of the other object:
      const size_t size = other.size();
      // Check if we need to do anything:
      if( ! size ) {
         return *this;
      }
 
      // Get a pointer to the start of the other object's payload:
      const void* otherPtr = other.toPtr();
 
      // Do the copy:
      this->copyRange( otherPtr, this->toPtr(), size );
 
      // Return a reference to this object:
      return *this;
   }
 
   std::unique_ptr< SG::IAuxTypeVector > TAuxVector::clone() const {
 
      return std::make_unique< TAuxVector >( *this );
   }
 
 
   void* TAuxVector::toPtr() {
 
      return m_proxy->At( 0 );
   }
 
   const void* TAuxVector::toPtr() const {
 
      return m_proxy->At( 0 );
   }
 
   void* TAuxVector::toVector() {
 
      return m_vec;
   }
 
   size_t TAuxVector::size() const {
 
      return m_proxy->Size();
   }
 
   bool TAuxVector::resize( size_t sz ) {
 
      const void* orig = this->getDataSpan().beg;
      m_proxy->Allocate( sz, false );
      this->storeDataSpan(); 
      return this->getDataSpan().beg == orig;
   }
 
   void TAuxVector::reserve( size_t ) {
 
      return;
   }
 
   bool TAuxVector::shift( size_t pos, ptrdiff_t offs ) {
 
      size_t eltsz = m_proxy->GetIncrement();
      if( offs < 0 ) {
 
         if( -offs > static_cast< ptrdiff_t >( pos ) ) {
            offs = -pos;
         }
         char* beg = reinterpret_cast< char* >( m_proxy->At( 0 ) );
         copyRange( beg + eltsz * pos,
                    beg + eltsz * ( pos + offs ),
                    m_proxy->Size() - pos );
         m_proxy->Allocate( m_proxy->Size() + offs, false );
         this->storeDataSpan(); 
         return true;
 
      } else if( offs > 0 ) {
 
         size_t oldsz = m_proxy->Size();
         m_proxy->Allocate( oldsz + offs, false );
         char* beg = reinterpret_cast< char* >( m_proxy->At( 0 ) );
         copyRange( beg + eltsz * pos,
                    beg + eltsz * ( pos + offs ),
                    m_proxy->Size() - pos - offs);
         clearRange( beg + eltsz * pos, offs );
         this->storeDataSpan(); 
         return false;
      }
 
      return true;
   }
 
   bool TAuxVector::insertMove (size_t pos,
                                void* src, size_t src_pos, size_t src_n,
                                SG::IAuxStore& /*srcStore*/)
   {
     size_t eltsz = m_proxy->GetIncrement();
     const void* orig = this->getDataSpan().beg;
 
     char* srcp = reinterpret_cast<char*> (src);
     char* begp = srcp + src_pos*eltsz;
 
     shift (pos, src_n);
     // FIXME: want move, not copy.
     // But i don't seem to be able to call move operations through cling,
     // so just use copy for now.
     copyRange (begp,
                reinterpret_cast<char*>(this->toPtr()) + pos*eltsz,
                src_n);
     this->storeDataSpan(); 
     return this->getDataSpan().beg == orig;
   }
 
 
   void TAuxVector::copyRange( const void* src, void* dst, size_t n ) {
 
      SG::AuxVectorInterface idst( auxid(), n, dst );
      m_factory->copy( auxid(),
                       idst, 0,
                       SG::AuxVectorInterface( auxid(), n, src ), 0,
                       n );
 
      return;
   }
 
   void TAuxVector::clearRange( void* dst, size_t n ) {
 
      // Size of an element in the vector:
      size_t eltsz = m_proxy->GetIncrement();
 
      // If the payload is a class:
      if( m_proxy->GetValueClass() ) {
         m_factory->clear (dst, 0, n);
      }
      // If the payload is an array of primitives, the cleaning is much simpler:
      else {
         memset( dst, 0, n * eltsz );
      }
 
      return;
   }
 
   SG::AuxDataSpanBase TAuxVector::getDataSpanImpl() const
   {
     return SG::AuxDataSpanBase( const_cast<void*> (toPtr()), size() );
   }
 
   void TAuxVector::storeDataSpan()
   {
     IAuxTypeVector::storeDataSpan( toPtr(), size() );
   }
 
} // namespace xAOD