SG::RootAuxVectorFactory Class Reference

Dynamic implementation of IAuxVectorFactory, relying on root's vector proxy. More...

#include <RootAuxVectorFactory.h>

Inheritance diagram for SG::RootAuxVectorFactory:

Collaboration diagram for SG::RootAuxVectorFactory:

Public Member Functions
	RootAuxVectorFactory (TClass *objClass)
	Constructor.
virtual	~RootAuxVectorFactory () override
	Destructor.
const RootUtils::Type &	rootType () const
	Return the ROOT type wrapper.
TClass *objClass	ATLAS_NOT_CONST_THREAD_SAFE () const
	Return the TClass for the overall object.
TClass *vecClass	ATLAS_NOT_CONST_THREAD_SAFE () const
	Return the TClass for the std::vector.
size_t	offset () const
	Return the offset of the vector within the object.
virtual std::unique_ptr< SG::IAuxTypeVector >	create (SG::auxid_t auxid, size_t size, size_t capacity, bool isLinked) const override
	Create a vector object of this type.
virtual std::unique_ptr< SG::IAuxTypeVector >	createFromData (SG::auxid_t auxid, void *data, IAuxTypeVector *linkedVector, bool isPacked, bool ownFlag, bool isLinked) const override
	Create a vector object of this type from a data blob.
virtual void	copy (SG::auxid_t auxid, AuxVectorData &dst, size_t dst_index, const AuxVectorData &src, size_t src_index, size_t n) const override
	Copy elements between vectors.
virtual void	copyForOutput (SG::auxid_t auxid, AuxVectorData &dst, size_t dst_index, const AuxVectorData &src, size_t src_index, size_t n) const override
	Copy elements between vectors, possibly applying thinning.
virtual void	swap (SG::auxid_t auxid, AuxVectorData &a, size_t aindex, AuxVectorData &b, size_t bindex, size_t n) const override
	Swap elements between vectors.
virtual void	clear (SG::auxid_t auxid, AuxVectorData &dst, size_t dst_index, size_t n) const override
	Clear a range of elements within a vector.
virtual size_t	getEltSize () const override
	Return the size of an element of this vector type.
virtual const std::type_info *	tiVec () const override
	Return the type_info of the overall object.
virtual bool	isDynamic () const override
	True if the vectors created by this factory work by dynamic emulation (via TVirtualCollectionProxy or similar); false if the std::vector code is used directly.
virtual const std::type_info *	tiAlloc () const override
	Return the type_info of the vector allocator.
virtual std::string	tiAllocName () const override
	Return the (demangled) name of the vector allocator.
void	toTransient (const EventContext &ctx, RootAuxVector &vec) const
	Perform post-read processing for one variable.
void	copy (SG::auxid_t auxid, AuxVectorData &&dst, size_t dst_index, const AuxVectorData &src, size_t src_index, size_t n) const
	Copy elements between vectors.

Private Types
enum	{   NONE , ELEMENT_LINK , ELEMENT_LINK_VECTOR , ELEMENT_LINK_NONPOINTER ,   DATA_LINK , DATA_LINK_VECTOR }
	Flag to tell whether we need to do thinning / toTrasnsient. More...

Private Member Functions
char *	copyImpl (SG::auxid_t auxid, AuxVectorData &dst, size_t dst_index, const AuxVectorData &src, size_t src_index, size_t n) const
	Helper for copy; returns a pointer to the first destination object, or nullptr if the destination was cleared rather than copied.

Private Attributes
TClass *	m_objClass
	The TClass for the overall object.
TClass *	m_vecClass
	The TClass for the std::vector.
size_t	m_offset
	Offset of the STL vector within the overall object.
RootUtils::Type	m_type
	Wrapper for the ROOT type of the element.
enum SG::RootAuxVectorFactory:: { ... }	m_isEL
	Flag to tell whether we need to do thinning / toTrasnsient.

Detailed Description

Dynamic implementation of IAuxVectorFactory, relying on root's vector proxy.

This is used for the case when we need to manipulate an aux data vector present in an input data file but we have neither a proper template instantiation for the factory (because the variable was never explicitly referenced), nor can we find a dictionary entry for the factory.j

This implementation works by relying entirely on the root dictionary information.

We may either be dealing directly with an STL vector class, or with embedded in another class (as for PackedContainer). Here, vecClass is the class of the STL vector and objClass is the overall object class. In the case of a direct STL vector, these are identical.

Definition at line 285 of file RootAuxVectorFactory.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

private

Flag to tell whether we need to do thinning / toTrasnsient.

Enumerator
NONE
ELEMENT_LINK
ELEMENT_LINK_VECTOR
ELEMENT_LINK_NONPOINTER
DATA_LINK
DATA_LINK_VECTOR

Definition at line 510 of file RootAuxVectorFactory.h.

       { NONE,
         ELEMENT_LINK, ELEMENT_LINK_VECTOR, ELEMENT_LINK_NONPOINTER,
         DATA_LINK,    DATA_LINK_VECTOR,
  } m_isEL;

Constructor & Destructor Documentation

RootAuxVectorFactory()

SG::RootAuxVectorFactory::RootAuxVectorFactory

(

TClass *

objClass

)

Constructor.

Parameters

vecClass

The TClass for the vector object.

Definition at line 384 of file RootAuxVectorFactory.cxx.

  : 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()

SG::RootAuxVectorFactory::~RootAuxVectorFactory ( )

overridevirtual

Destructor.

Definition at line 471 of file RootAuxVectorFactory.cxx.

{
}

Member Function Documentation

ATLAS_NOT_CONST_THREAD_SAFE() [1/2]

TClass *vecClass SG::RootAuxVectorFactory::ATLAS_NOT_CONST_THREAD_SAFE ( ) const

inline

Return the TClass for the std::vector.

(Returning non-const TClass* ok here; TClass is internally thread-safe.)

Definition at line 321 of file RootAuxVectorFactory.h.

{ return m_vecClass; }

ATLAS_NOT_CONST_THREAD_SAFE() [2/2]

TClass *objClass SG::RootAuxVectorFactory::ATLAS_NOT_CONST_THREAD_SAFE ( ) const

inline

Return the TClass for the overall object.

(Returning non-const TClass* ok here; TClass is internally thread-safe.)

Definition at line 313 of file RootAuxVectorFactory.h.

{ return m_objClass; }

clear()

void SG::RootAuxVectorFactory::clear ( SG::auxid_t auxid, AuxVectorData & dst, size_t dst_index, size_t n ) const

overridevirtual

Clear a range of elements within a vector.

Parameters

auxid	The aux data item being operated on.
dst	Container holding the element
dst_index	Index of the first element in the vector.
n	Number of elements to clear.

Implements SG::IAuxTypeVectorFactory.

Definition at line 657 of file RootAuxVectorFactory.cxx.

{
  if (n == 0) return;
  m_type.clearRange (dst.getDataArray (auxid), dst_index, n);
}

copy() [1/2]

void SG::IAuxTypeVectorFactory::copy ( SG::auxid_t auxid, AuxVectorData && dst, size_t dst_index, const AuxVectorData & src, size_t src_index, size_t n ) const

inlineinherited

Copy elements between vectors.

Parameters

auxid	The aux data item being operated on.
dst	Container for the destination vector. Declared as a rvalue reference to allow passing a temporary here (such as from AuxVectorInterface).
dst_index	Index of the first destination element in the vector.
src	Container for the source vector.
src_index	Index of the first source element in the vector.
n	Number of elements to copy.

dst and @ src can be either the same or different.

Definition at line 132 of file IAuxTypeVectorFactory.h.

  {
    copy (auxid, dst, dst_index, src, src_index, n);
  }

copy() [2/2]

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

overridevirtual

Copy elements between vectors.

Parameters

auxid	The aux data item being operated on.
dst	Container for the destination vector.
dst_index	Index of the first destination element in the vector.
src	Container for the source vector.
src_index	Index of the first source element in the vector.
n	Number of elements to copy.

dst and @ src can be either the same or different.

Implements SG::IAuxTypeVectorFactory.

Definition at line 572 of file RootAuxVectorFactory.cxx.

{
  (void)copyImpl (auxid, dst, dst_index, src, src_index, n);
}

copyForOutput()

void SG::RootAuxVectorFactory::copyForOutput ( SG::auxid_t auxid, AuxVectorData & dst, size_t dst_index, const AuxVectorData & src, size_t src_index, size_t n ) const

overridevirtual

Copy elements between vectors, possibly applying thinning.

Parameters

auxid	The aux data item being operated on.
dst	Container for the destination vector.
dst_index	Index of the first destination element in the vector.
src	Container for the source vector.
src_index	Index of source element in the vector.
src_index	Index of the first source element in the vector.
n	Number of elements to copy.

dst and @ src can be either the same or different.

Implements SG::IAuxTypeVectorFactory.

Definition at line 595 of file RootAuxVectorFactory.cxx.

{
  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());
  }
}

copyImpl()

char * SG::RootAuxVectorFactory::copyImpl ( SG::auxid_t auxid, AuxVectorData & dst, size_t dst_index, const AuxVectorData & src, size_t src_index, size_t n ) const

private

Helper for copy; returns a pointer to the first destination object, or nullptr if the destination was cleared rather than copied.

Definition at line 530 of file RootAuxVectorFactory.cxx.

{
  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;
    }
  }
}

create()

std::unique_ptr< SG::IAuxTypeVector > SG::RootAuxVectorFactory::create ( SG::auxid_t auxid, size_t size, size_t capacity, bool isLinked ) const

overridevirtual

Create a vector object of this type.

Parameters

auxid	ID for the variable being created.
size	Initial size of the new vector.
capacity	Initial capacity of the new vector.
isLinked	True if this variable is linked from another one.

Returns a newly-allocated object.

Parameters

auxid	ID for the variable being created.
size	Initial size of the new vector.
capacity	Initial capacity of the new vector.
isLinked	True if this variable is linked from another one.

Implements SG::IAuxTypeVectorFactory.

Definition at line 484 of file RootAuxVectorFactory.cxx.

{
  return std::make_unique<RootAuxVector> (this, auxid, size, capacity,
                                          isLinked);
}

createFromData()

std::unique_ptr< SG::IAuxTypeVector > SG::RootAuxVectorFactory::createFromData ( SG::auxid_t auxid, void * data, IAuxTypeVector * linkedVector, bool isPacked, bool ownFlag, bool isLinked ) const

overridevirtual

Create a vector object of this type from a data blob.

Parameters

auxid	ID for the variable being created.
data	The vector object.
linkedVector	The interface for another variable linked to this one, or nullptr if there isn't one. (We do not take ownership.)
isPacked	If true, data is a PackedContainer.
ownFlag	If true, the newly-created IAuxTypeVector object will take ownership of data.
isLinked	True if this variable is linked from another one.

If the element type is T, then data should be a pointer to a std::vector<T> object, which was obtained with new.

This version does not support packed containers, so isPacked must be false.

Returns a newly-allocated object.

Implements SG::IAuxTypeVectorFactory.

Definition at line 515 of file RootAuxVectorFactory.cxx.

{
  if (linkedVector) std::abort();
  return std::make_unique<RootAuxVector> (this, auxid, data, isPacked, ownFlag,
                                          isLinked);
}

getEltSize()

size_t SG::RootAuxVectorFactory::getEltSize ( ) const

overridevirtual

Return the size of an element of this vector type.

Implements SG::IAuxTypeVectorFactory.

Definition at line 669 of file RootAuxVectorFactory.cxx.

{
  return m_type.getSize();
}

isDynamic()

bool SG::RootAuxVectorFactory::isDynamic ( ) const

overridevirtual

True if the vectors created by this factory work by dynamic emulation (via TVirtualCollectionProxy or similar); false if the std::vector code is used directly.

Implements SG::IAuxTypeVectorFactory.

Definition at line 689 of file RootAuxVectorFactory.cxx.

{
  return true;
}

offset()

size_t SG::RootAuxVectorFactory::offset ( ) const

inline

Return the offset of the vector within the object.

Definition at line 327 of file RootAuxVectorFactory.h.

{ return m_offset; }

rootType()

const RootUtils::Type & SG::RootAuxVectorFactory::rootType ( ) const

inline

Return the ROOT type wrapper.

Definition at line 305 of file RootAuxVectorFactory.h.

{ return m_type; }

swap()

void SG::RootAuxVectorFactory::swap ( SG::auxid_t auxid, AuxVectorData & a, size_t aindex, AuxVectorData & b, size_t bindex, size_t n ) const

overridevirtual

Swap elements between vectors.

Parameters

auxid	The aux data item being operated on.
a	Container for the first vector.
aindex	Index of the first element in the first vector.
b	Container for the second vector.
bindex	Index of the first element in the second vector.
n	Number of elements to swap.

a and @ b can be either the same or different. However, the ranges should not overlap.

Implements SG::IAuxTypeVectorFactory.

Definition at line 638 of file RootAuxVectorFactory.cxx.

{
  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);
}

tiAlloc()

const std::type_info * SG::RootAuxVectorFactory::tiAlloc ( ) const

overridevirtual

Return the type_info of the vector allocator.

May be nullptr for a dynamic vector.

Implements SG::IAuxTypeVectorFactory.

Definition at line 700 of file RootAuxVectorFactory.cxx.

{
  return nullptr;
}

tiAllocName()

std::string SG::RootAuxVectorFactory::tiAllocName ( ) const

overridevirtual

Return the (demangled) name of the vector allocator.

Implements SG::IAuxTypeVectorFactory.

Definition at line 709 of file RootAuxVectorFactory.cxx.

{
  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;
}

tiVec()

const std::type_info * SG::RootAuxVectorFactory::tiVec ( ) const

overridevirtual

Return the type_info of the overall object.

Implements SG::IAuxTypeVectorFactory.

Definition at line 678 of file RootAuxVectorFactory.cxx.

{
  return m_objClass->GetTypeInfo();
}

toTransient()

void SG::RootAuxVectorFactory::toTransient	(	const EventContext &	ctx,
		RootAuxVector &	vec ) const

Perform post-read processing for one variable.

Parameters

ctx	The current event context.
vec	The variable to process.

Some object types require some processing after being read before they are usable. This can be indicated by specializing SG::ToTransient for the vector type containing the variable. This method will call such a ToTransient method on the contents, if one is defined.

Definition at line 736 of file RootAuxVectorFactory.cxx.

{
  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);
      }
    }
  }
}

Member Data Documentation

[]

enum { ... } SG::RootAuxVectorFactory::m_isEL

Flag to tell whether we need to do thinning / toTrasnsient.

m_objClass

TClass* SG::RootAuxVectorFactory::m_objClass

private

The TClass for the overall object.

Definition at line 498 of file RootAuxVectorFactory.h.

m_offset

size_t SG::RootAuxVectorFactory::m_offset

private

Offset of the STL vector within the overall object.

Definition at line 504 of file RootAuxVectorFactory.h.

m_type

RootUtils::Type SG::RootAuxVectorFactory::m_type

private

Wrapper for the ROOT type of the element.

Definition at line 507 of file RootAuxVectorFactory.h.

m_vecClass

TClass* SG::RootAuxVectorFactory::m_vecClass

private

The TClass for the std::vector.

Definition at line 501 of file RootAuxVectorFactory.h.

---

The documentation for this class was generated from the following files:

• RootAuxVectorFactory.h
• RootAuxVectorFactory.cxx