RootAuxVectorFactory.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
 
#include "AthContainersRoot/RootAuxVectorFactory.h"
#include "AthContainers/AuxVectorData.h"
#include "AthContainers/tools/error.h"
#include "AthContainers/normalizedTypeinfoName.h"
#include "AthLinks/ElementLinkBase.h"
#include "AthLinks/DataLinkBase.h"
#include "AthenaKernel/proxyDictFromEventContext.h"
#include "CxxUtils/ClassName.h"
#include "CxxUtils/checker_macros.h"
#include "TClass.h"
#include "TVirtualCollectionProxy.h"
#include "TROOT.h"
#include <iostream>
#include <stdexcept>
 
 
namespace {
 

TClass* lookupVectorType (TClass *cl)
{
  std::string tname = cl->GetName();
  tname += "::vector_type";
  TDataType* typ = gROOT->GetType (tname.c_str());
  if (typ)
    return TClass::GetClass (typ->GetFullTypeName());
  return nullptr;
}
 
 
} // anonymous namespace
 
 
namespace SG {
 

RootAuxVector::RootAuxVector (const RootAuxVectorFactory* factory,
                              SG::auxid_t auxid,
                              size_t size, size_t /*capacity*/,
                              bool isLinked)
  : IAuxTypeVector (auxid, isLinked),
    m_factory (factory),
    m_ownFlag (true)
{
  const TClass* vecClass = factory->vecClass();
  m_proxy.reset (vecClass->GetCollectionProxy()->Generate());
  m_obj = factory->objClass()->New ();
  m_vec = reinterpret_cast<char*> (m_obj) + factory->offset();
  m_proxy->PushProxy (m_vec);
  this->resize (size);
}
 

RootAuxVector::RootAuxVector (const RootAuxVectorFactory* factory,
                              SG::auxid_t auxid,
                              void* data,
                              bool isPacked,
                              bool ownFlag,
                              bool isLinked)
  : IAuxTypeVector (auxid, isLinked),
    m_factory (factory),
    m_ownFlag (ownFlag)
{
  if (isPacked) std::abort();
  const TClass* vecClass = factory->vecClass();
  m_proxy.reset (vecClass->GetCollectionProxy()->Generate());
  m_obj = data;
  m_vec = reinterpret_cast<char*> (m_obj) + factory->offset();
  m_proxy->PushProxy (m_vec);
}
 

RootAuxVector::RootAuxVector (const RootAuxVector& other)
  : IAuxTypeVector (other),
    m_factory (other.m_factory),
    m_proxy (other.m_proxy->Generate()),
    m_ownFlag (true)
{
  m_obj = m_factory->objClass()->New ();
  m_vec = reinterpret_cast<char*> (m_obj) + m_factory->offset();
  m_proxy->PushProxy (m_vec);
  size_t sz = other.size();
  this->resize (sz);
 
  if (sz > 0) {
    const RootUtils::Type& rootType = m_factory->rootType();
    const void* otherPtr = other.toPtr();
    rootType.copyRange (this->toPtr(), otherPtr, sz);
  }
}
 

RootAuxVector::~RootAuxVector()
{
  if (m_ownFlag)
    m_factory->objClass()->Destructor (m_obj);
}
 

std::unique_ptr<SG::IAuxTypeVector> RootAuxVector::clone() const
{
  return std::make_unique<RootAuxVector> (*this);
}
 

void* RootAuxVector::toPtr ()
{
  if (m_proxy->Size() == 0)
    return 0;
  return m_proxy->At(0);
}
 

const void* RootAuxVector::toPtr () const
{
  if (m_proxy->Size() == 0)
    return 0;
  TVirtualCollectionProxy* proxy ATLAS_THREAD_SAFE = m_proxy.get();
  return proxy->At(0);
}
 

void* RootAuxVector::toVector ()
{
  return m_obj;
}
 

size_t RootAuxVector::size() const
{
  return m_proxy->Size();
}
 

bool RootAuxVector::resize (size_t sz)
{
  const void* orig = this->getDataSpan().beg;
  m_proxy->Allocate(sz, false);
  this->storeDataSpan();
  return this->getDataSpan().beg == orig;
}
 

void RootAuxVector::reserve (size_t /*sz*/)
{
}
 

bool RootAuxVector::shift (size_t pos, ptrdiff_t offs)
{
  size_t eltsz = m_proxy->GetIncrement();
 
  const RootUtils::Type& rootType = m_factory->rootType();
 
  if (offs < 0) {
    if (-offs > static_cast<ptrdiff_t>(pos)) offs = -pos;
    char* beg = reinterpret_cast<char*>(m_proxy->At(0));
    rootType.copyRange (beg + eltsz*(pos+offs),
                        beg + eltsz*pos,
                        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));
    if (pos < oldsz)
      rootType.copyRange (beg + eltsz*(pos+offs),
                          beg + eltsz*pos,
                          oldsz - pos);
    rootType.clearRange (beg + eltsz*pos, offs);
    this->storeDataSpan();
    return false;
  }
  return true;
}
 

bool RootAuxVector::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;
  const RootUtils::Type& rootType = m_factory->rootType();
 
  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.
  rootType.copyRange (reinterpret_cast<char*>(this->toPtr()) + pos*eltsz,
                      begp, src_n);
  this->storeDataSpan();
  return this->getDataSpan().beg == orig;
}
 

const std::type_info* RootAuxVector::objType() const
{
  return m_factory->objClass()->GetTypeInfo();
}
 

void RootAuxVector::toTransient (const EventContext& ctx)
{
  m_factory->toTransient (ctx, *this);
}
 

AuxDataSpanBase RootAuxVector::getDataSpanImpl() const
{
  void* ptr ATLAS_THREAD_SAFE = const_cast<void*>(this->toPtr());
  return AuxDataSpanBase (ptr, m_proxy->Size());
}
 

void RootAuxVector::storeDataSpan()
{
  IAuxTypeVector::storeDataSpan (this->toPtr(), m_proxy->Size());
}
 
 
//==================================================================
 

RootAuxVectorFactory::RootAuxVectorFactory (TClass* objClass)
  : m_objClass (objClass),
    m_vecClass (objClass),
    m_offset (0),
    m_isEL (NONE)
{
  TVirtualCollectionProxy* proxy = m_vecClass->GetCollectionProxy();
 
  if (!proxy) {
    TClass* vecClass = lookupVectorType (objClass);
    if (vecClass) {
      m_vecClass = vecClass;
      Int_t offs = objClass->GetBaseClassOffset (vecClass);
      if (offs >= 0) {
        m_offset = offs;
        proxy = vecClass->GetCollectionProxy();
      }
      else {
        ATHCONTAINERS_ERROR("RootAuxVectorFactory::RootAuxVectorFactory",
                            std::string("Can't find vector base class in ") +
                            objClass->GetName());
      }
    }
  }
 
  if (!proxy) {
    std::string err = "Can't find collection proxy for ";
    err += m_vecClass->GetName();
    throw std::runtime_error (err.c_str());
  }
 
  if (m_vecClass->GetTypeInfo() == 0) {
    ATHCONTAINERS_ERROR("RootAuxVectorFactory::RootAuxVectorFactory",
                        std::string("No type_info available for class ") +
                        m_vecClass->GetName() +
                        std::string(".  There is probably a missing dictionary.  We will likely crash further on."));
  }
 
  TClass* eltClass = proxy->GetValueClass();
  if (eltClass) {
    m_type.init (eltClass);
 
    const std::type_info* ti = eltClass->GetTypeInfo();
    if (ti) {
 
      static const CxxUtils::ClassName pat1 ("ElementLink<$T>");
      static const CxxUtils::ClassName pat2 ("std::vector<ElementLink<$T> >");
      static const CxxUtils::ClassName pat3 ("DataLink<$T>");
      static const CxxUtils::ClassName pat4 ("std::vector<DataLink<$T> >");
 
      CxxUtils::ClassName clname (SG::normalizedTypeinfoName (*ti));
      CxxUtils::ClassName::match_t matches;
      if (clname.match (pat1, matches)) {
        m_isEL = ELEMENT_LINK;
        if (eltClass->GetBaseClass ("ElementLinkBase") == nullptr) {
          m_isEL = ELEMENT_LINK_NONPOINTER;
        }
      }
      else if (clname.match (pat2, matches)) {
        m_isEL = ELEMENT_LINK_VECTOR;
 
        TVirtualCollectionProxy* proxy2 = eltClass->GetCollectionProxy();
        if (proxy2) {
          TClass* innerEltClass = proxy2->GetValueClass();
          if (innerEltClass) {
            if (innerEltClass->GetBaseClass ("ElementLinkBase") == nullptr) {
              m_isEL = ELEMENT_LINK_NONPOINTER;
            }
          }
        }
      }
      else if (clname.match (pat3, matches)) {
        m_isEL = DATA_LINK;
      }
      else if (clname.match (pat4, matches)) {
        m_isEL = DATA_LINK_VECTOR;
      }
    }
  }
  else
    m_type.init (proxy->GetType());
}
 

RootAuxVectorFactory::~RootAuxVectorFactory()
{
}
 

std::unique_ptr<SG::IAuxTypeVector>
RootAuxVectorFactory::create (SG::auxid_t auxid,
                              size_t size,
                              size_t capacity,
                              bool isLinked) const
{
  return std::make_unique<RootAuxVector> (this, auxid, size, capacity,
                                          isLinked);
}
 

std::unique_ptr<SG::IAuxTypeVector>
RootAuxVectorFactory::createFromData (SG::auxid_t auxid,
                                      void* data,
                                      IAuxTypeVector* linkedVector,
                                      bool isPacked,
                                      bool ownFlag,
                                      bool isLinked) const
{
  if (linkedVector) std::abort();
  return std::make_unique<RootAuxVector> (this, auxid, data, isPacked, ownFlag,
                                          isLinked);
}
 

char* RootAuxVectorFactory::copyImpl (SG::auxid_t auxid,
                                      AuxVectorData& dst,
                                      size_t dst_index,
                                      const AuxVectorData& src,
                                      size_t src_index,
                                      size_t n) const
{
  if (n == 0) return nullptr;
  size_t eltsz = m_type.getSize();
  char* dstptr = reinterpret_cast<char*> (dst.getDataArray (auxid));
  if (&src == &dst) {
    // Source and destination containers are the same,
    // so we don't need to bother with fetching the src pointer.
    // copyRange properly handles overlapping regions.
    m_type.copyRange (dstptr + eltsz*dst_index, dstptr + eltsz*src_index, n);
    return dstptr + eltsz*dst_index;
  }
  else {
    const char* srcptr = reinterpret_cast<const char*>(src.getDataArrayAllowMissing (auxid));
    if (srcptr) {
      m_type.copyRange (dstptr + eltsz*dst_index, srcptr + eltsz*src_index, n);
      return dstptr + eltsz*dst_index;
    }
    else {
      m_type.clearRange (dstptr + eltsz*dst_index, n);
      return nullptr;
    }
  }
}
 

void RootAuxVectorFactory::copy (SG::auxid_t auxid,
                                 AuxVectorData& dst,
                                 size_t dst_index,
                                 const AuxVectorData& src,
                                 size_t src_index,
                                 size_t n) const
{
  (void)copyImpl (auxid, dst, dst_index, src, src_index, n);
}
 

void RootAuxVectorFactory::copyForOutput (SG::auxid_t auxid,
                                          AuxVectorData& dst,        size_t dst_index,
                                          const AuxVectorData& src,  size_t src_index,
                                          size_t n) const
{
  char* dstptr = copyImpl (auxid, dst, dst_index, src, src_index, n);
 
  if (m_isEL == ELEMENT_LINK) {
    size_t eltsz = m_type.getSize();
    for (size_t i = 0; i < n; i++) {
      reinterpret_cast<ElementLinkBase*>(dstptr + i*eltsz)->thin();
    }
  }
  else if (m_isEL == ELEMENT_LINK_VECTOR) {
    size_t eltsz = m_type.getSize();
    for (size_t i = 0; i < n; i++) {
      std::vector<ElementLinkBase>& v = 
        *reinterpret_cast<std::vector<ElementLinkBase>* > (dstptr +i*eltsz);
      for (ElementLinkBase& el : v) {
        el.thin();
      }
    }
  }
  else if (m_isEL == ELEMENT_LINK_NONPOINTER) {
    TVirtualCollectionProxy* proxy = m_vecClass->GetCollectionProxy();
    TClass* eltClass = proxy->GetValueClass();
    ATHCONTAINERS_ERROR("RootAuxVectorFactory::copyForOutput",
                        std::format("Tried to copy an auxiliary variable of type {}.  However, the target type is not a DataVector and does not have a pointer value type.  Such types are only fully supported for fully specified Factory objects, not for this dynamic factory using ROOT reflection information.  Perhaps you are trying to write this type by mistake.  Otherwise, try creating a SG::Accessor object for this type during event processing to ensure a proper Factory is available.",
                                    eltClass->GetName()));
  }
}
 

void RootAuxVectorFactory::swap (SG::auxid_t auxid,
                                 AuxVectorData& a, size_t aindex,
                                 AuxVectorData& b, size_t bindex,
                                 size_t n) const
{
  if (n == 0) return;
  void* aptr = a.getDataArray (auxid);
  void* bptr = &a == &b ? aptr : b.getDataArray (auxid);
  m_type.swapRange (aptr, aindex, bptr, bindex, n);
}
 

void RootAuxVectorFactory::clear (SG::auxid_t auxid,
                                  AuxVectorData& dst, size_t dst_index,
                                  size_t n) const
{
  if (n == 0) return;
  m_type.clearRange (dst.getDataArray (auxid), dst_index, n);
}
 

size_t RootAuxVectorFactory::getEltSize() const
{
  return m_type.getSize();
}
 

const std::type_info* RootAuxVectorFactory::tiVec() const
{
  return m_objClass->GetTypeInfo();
}
 

bool RootAuxVectorFactory::isDynamic() const
{
  return true;
}
 

const std::type_info* RootAuxVectorFactory::tiAlloc() const
{
  return nullptr;
}
 

std::string RootAuxVectorFactory::tiAllocName() const
{
  std::string name = SG::normalizedTypeinfoName (*m_vecClass->GetTypeInfo());
  CxxUtils::ClassName cn (name);
  std::string alloc_name;
  if (cn.ntargs() >= 2) {
    alloc_name = cn.targ(1).fullName();
  }
  else if (cn.ntargs() == 1) {
    alloc_name = "std::allocator<" + cn.targ(0).fullName();
    if (alloc_name[alloc_name.size()-1] == '>') alloc_name += " ";
    alloc_name += ">";
  }
  return alloc_name;
}
 

void RootAuxVectorFactory::toTransient (const EventContext& ctx,
                                        RootAuxVector& vec) const
{
  if (m_isEL == NONE) {
    return;
  }
  if (m_isEL == ELEMENT_LINK_NONPOINTER) {
    ATHCONTAINERS_ERROR("RootAuxVectorFactory::toTransient",
                        std::string("Cannot call toTransient for ElementLink with non-pointer element: ") +
                        m_vecClass->GetName());
    return;
  }
 
  char* ptr = reinterpret_cast<char*> (vec.toPtr());
  size_t n = vec.size();
  IProxyDict* pdict = Atlas::proxyDictFromEventContext (ctx);
  size_t eltsz = m_type.getSize();
 
  if (m_isEL == ELEMENT_LINK) {
    for (size_t i = 0; i < n; i++) {
      reinterpret_cast<ElementLinkBase*>(ptr + i*eltsz)->toTransient (pdict);
    }
  }
  else if (m_isEL == ELEMENT_LINK_VECTOR) {
    for (size_t i = 0; i < n; i++) {
      std::vector<ElementLinkBase>& v =
        *reinterpret_cast<std::vector<ElementLinkBase>* > (ptr +i*eltsz);
      for (ElementLinkBase& el : v) {
        el.toTransient (pdict);
      }
    }
  }
  else if (m_isEL == DATA_LINK) {
    for (size_t i = 0; i < n; i++) {
      reinterpret_cast<DataLinkBase*>(ptr + i*eltsz)->toTransient (pdict);
    }
  }
  else if (m_isEL == DATA_LINK_VECTOR) {
    for (size_t i = 0; i < n; i++) {
      std::vector<DataLinkBase>& v =
        *reinterpret_cast<std::vector<DataLinkBase>* > (ptr +i*eltsz);
      for (DataLinkBase& dl : v) {
        dl.toTransient (pdict);
      }
    }
  }
}
 
 
} // namespace SG