RootAuxVectorFactory.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 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 "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->toPtr();
  m_proxy->Allocate(sz, false);
  return this->toPtr() == 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);
    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);
    return false;
  }
  return true;
}
 
 
bool RootAuxVector::insertMove (size_t pos, void* beg, void* end,
                                SG::IAuxStore& /*srcStore*/)
{
  size_t eltsz = m_proxy->GetIncrement();
  const void* orig = this->toPtr();
  const RootUtils::Type& rootType = m_factory->rootType();
 
  char* begp = reinterpret_cast<char*> (beg);
  char* endp = reinterpret_cast<char*> (end);
  size_t nelt = (endp-begp) / eltsz;
 
  shift (pos, nelt);
  // 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,
                      beg, nelt);
  return this->toPtr() == orig;
}
 
 
const std::type_info* RootAuxVector::objType() const
{
  return m_factory->objClass()->GetTypeInfo();
}
 
 
//==================================================================
 
 
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> >");
 
      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
    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) {
    ATHCONTAINERS_ERROR("RootAuxVectorFactory::copyForOutput",
                        std::string("Cannot apply thinning for ElementLink with non-pointer element: ") +
                        m_vecClass->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;
}
 
 
} // namespace SG