xAOD::TAuxVectorFactory Class Reference

Auxiliary vector factory based on a ROOT dictionary. More...

#include <TAuxVectorFactory.h>

Inheritance diagram for xAOD::TAuxVectorFactory:

Collaboration diagram for xAOD::TAuxVectorFactory:

Public Member Functions
	TAuxVectorFactory (::TClass *cl)
	Constructor, setting up the object based on a dictionary.
virtual	~TAuxVectorFactory ()
	Destructor.
	TAuxVectorFactory (const TAuxVectorFactory &)=delete
TAuxVectorFactory &	operator= (const TAuxVectorFactory &)=delete
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.
Functions implementing the SG::IAuxTypeVectorFactory interface
virtual std::unique_ptr< SG::IAuxTypeVector >	create (SG::auxid_t auxid, size_t size, size_t capacity, bool isLinked) const override
	Create a new vector in memory with the requested size and capacity.
virtual std::unique_ptr< SG::IAuxTypeVector >	createFromData (SG::auxid_t auxid, void *data, SG::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, SG::AuxVectorData &dst, size_t dst_index, const SG::AuxVectorData &src, size_t src_index, size_t n) const override
	Copy elements from one location to another.
virtual void	copyForOutput (SG::auxid_t auxid, SG::AuxVectorData &dst, size_t dst_index, const SG::AuxVectorData &src, size_t src_index, size_t n) const override
	Copy one element from one location to another.
virtual void	swap (SG::auxid_t auxid, SG::AuxVectorData &a, size_t aindex, SG::AuxVectorData &b, size_t bindex, size_t n) const override
	Swap the payload of two ranges of elements in memory.
void	clear (void *dst, size_t dst_index, size_t n) const
	Clear the payload of a given range inside a vector.
virtual void	clear (SG::auxid_t auxid, SG::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
	Size of the elements inside the vector type.
virtual const std::type_info *	tiVec () const override
	Type info of the vector type handled by the factory object.
virtual bool	isDynamic () const override
	Type of the factory.
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.

Private Attributes
::TClass *	m_class
	The type that this factory operates on.
::TVirtualCollectionProxy *	m_proxy
	ROOT's description of the vector type.
RootUtils::TSMethodCall m_assign	ATLAS_THREAD_SAFE
	Assignment operator.
void *	m_defElt
	Pointer to a default element object in memory.

Detailed Description

Auxiliary vector factory based on a ROOT dictionary.

Factory implementation that creates vectors that can be operated on using ROOT's dictionary for the underlying vector type.

The code is pretty much a copy of what Scott wrote for RootStorageSvc for the offline code.

Author

Scott Snyder Scott.nosp@m..Sny.nosp@m.der@c.nosp@m.ern..nosp@m.ch

Attila Krasznahorkay Attil.nosp@m.a.Kr.nosp@m.aszna.nosp@m.hork.nosp@m.ay@ce.nosp@m.rn.c.nosp@m.h

Definition at line 30 of file TAuxVectorFactory.h.

Constructor & Destructor Documentation

TAuxVectorFactory() [1/2]

xAOD::TAuxVectorFactory::TAuxVectorFactory

(

::TClass *

cl

)

Constructor, setting up the object based on a dictionary.

Definition at line 22 of file TAuxVectorFactory.cxx.

      : m_class( cl ), m_proxy( cl->GetCollectionProxy() ),
        m_defElt( 0 ) {
 
      // A little sanity check:
      if( ! m_proxy ) {
         ::Fatal( "xAOD::TAuxVectorFactory::TAuxVectorFactory",
                  XAOD_MESSAGE( "No collection proxy found for type %s" ),
                  cl->GetName() );
      }
      else {
         // Check if the elements of the vector are objects:
        ::TClass* eltClass = m_proxy->GetValueClass();
        if( eltClass ) {
           // Initialise the assignment operator's method call:
          std::string proto = "const ";
          proto += eltClass->GetName();
          proto += "&";
          m_assign.setProto( eltClass, "operator=", proto );
          if( m_assign.call() == nullptr ) {
             ::Warning( "xAOD::TAuxVectorFactory::TAuxVectorFactory",
                        XAOD_MESSAGE( "Can't get assignment operator for "
                                      "class %s" ),
                        eltClass->GetName() );
          }
          m_defElt = eltClass->New();
        }
      }
   }

~TAuxVectorFactory()

xAOD::TAuxVectorFactory::~TAuxVectorFactory ( )

virtual

Destructor.

Definition at line 52 of file TAuxVectorFactory.cxx.

                                         {
 
      // Remove the default element from memory if it exists:
      if( m_defElt ) {
         m_proxy->GetValueClass()->Destructor( m_defElt );
      }
   }

TAuxVectorFactory() [2/2]

xAOD::TAuxVectorFactory::TAuxVectorFactory ( const TAuxVectorFactory & )

delete

Member Function Documentation

clear() [1/2]

void xAOD::TAuxVectorFactory::clear ( SG::auxid_t auxid, SG::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 230 of file TAuxVectorFactory.cxx.

                                                   {
 
      clear( dst.getDataArray (auxid), dst_index, n );
      return;
   }

clear() [2/2]

void xAOD::TAuxVectorFactory::clear	(	void *	dst,
		size_t	dst_index,
		size_t	n ) const

Clear the payload of a given range inside a vector.

Definition at line 200 of file TAuxVectorFactory.cxx.

                                                   {
 
      if (n == 0) return;
 
      // The size of one element in memory:
      const size_t eltsz = m_proxy->GetIncrement();
 
      // Get the memory address of the element:
      char* dptr = reinterpret_cast< char* >( dst ) + eltsz * dst_index;
 
      TMethodCall* mc = m_assign.call();
      if( mc ) {
         // Assign the default element's contents to this object:
         for (size_t i = 0; i < n; ++i) {
            mc->ResetParam();
            mc->SetParam( ( Long_t ) m_defElt );
            mc->Execute( static_cast<void*>( dptr ) );
            dptr += eltsz;
         }
      } else {
         // Set the memory to zero:
         memset( dst, 0, eltsz*n );
      }
 
      return;
   }

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 xAOD::TAuxVectorFactory::copy ( SG::auxid_t auxid, SG::AuxVectorData & dst, size_t dst_index, const SG::AuxVectorData & src, size_t src_index, size_t n ) const

overridevirtual

Copy elements from one location to another.

Implements SG::IAuxTypeVectorFactory.

Definition at line 81 of file TAuxVectorFactory.cxx.

                                                  {
 
      if (n == 0) return;
 
      // The size of one element in memory:
      const size_t eltsz = m_proxy->GetIncrement();
 
      // Get the location of the source and target element in memory:
      char* dstptr = reinterpret_cast<char*> (dst.getDataArray (auxid));
      const char* srcptr = &dst == &src ? dstptr : reinterpret_cast<const char*>(src.getDataArray (auxid));
      dstptr += eltsz * dst_index;
      srcptr += eltsz * src_index;
 
      // Do the copy either using the assignment operator of the type, or using
      // simple memory copying:
      TMethodCall* mc = m_assign.call();
      if( mc ) {
        auto copyone = [mc] (void* dst_, const void* src_)
          {
            mc->ResetParam();
            mc->SetParam( ( Long_t ) src_ );
            mc->Execute( dst_ );
          };
 
         // If the source range doesn't overlap with the destination:
         if( dstptr > srcptr && ( srcptr + n * eltsz ) > dstptr ) {
            for( size_t i = n - 1; i < n; --i ) {
               copyone( dstptr + i*eltsz, srcptr + i*eltsz );
            }
         }
         // If it does:
         else {
            for( size_t i = 0; i < n; ++i ) {
               copyone( dstptr + i*eltsz, srcptr + i*eltsz );
            }
         }
 
      } else {
         memmove( dstptr, srcptr, n * eltsz );
      }
 
      return;
   }

copyForOutput()

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

overridevirtual

Copy one element from one location to another.

Implements SG::IAuxTypeVectorFactory.

Definition at line 128 of file TAuxVectorFactory.cxx.

                                                          {
 
      // Do a "regular" copy.
      copy( auxid, dst, dst_index, src, src_index, n );
 
      ::Warning( "xAOD::TAuxVectorFactory::TAuxVectorFactory",
                 XAOD_MESSAGE( "copyForOutput called; should only be used "
                               "with pool converters." ) );
   }

create()

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

overridevirtual

Create a new vector in memory with the requested size and capacity.

Implements SG::IAuxTypeVectorFactory.

Definition at line 61 of file TAuxVectorFactory.cxx.

                                                    {
 
     return std::make_unique< TAuxVector >( this, auxid,
                                            CxxUtils::as_const_ptr(m_class),
                                            size, capacity,
                                            isLinked );
   }

createFromData()

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

overridevirtual

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

Implements SG::IAuxTypeVectorFactory.

Definition at line 71 of file TAuxVectorFactory.cxx.

                                                     {
 
      std::abort();
   }

getEltSize()

size_t xAOD::TAuxVectorFactory::getEltSize ( ) const

overridevirtual

Size of the elements inside the vector type.

Implements SG::IAuxTypeVectorFactory.

Definition at line 239 of file TAuxVectorFactory.cxx.

                                              {
 
      return m_proxy->GetIncrement();
   }

isDynamic()

virtual bool xAOD::TAuxVectorFactory::isDynamic ( ) const

inlineoverridevirtual

Type of the factory.

Implements SG::IAuxTypeVectorFactory.

Definition at line 91 of file TAuxVectorFactory.h.

{ return true; }

operator=()

TAuxVectorFactory & xAOD::TAuxVectorFactory::operator= ( const TAuxVectorFactory & )

delete

swap()

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

overridevirtual

Swap the payload of two ranges of elements in memory.

Implements SG::IAuxTypeVectorFactory.

Definition at line 142 of file TAuxVectorFactory.cxx.

                                                  {
 
      if (n == 0) return;
 
      // The size of one element in memory:
      const size_t eltsz = m_proxy->GetIncrement();
 
      // Get the location of the two elements in memory:
      char* aptr = reinterpret_cast<char*>( a.getDataArray (auxid) );
      char* bptr = &a == &b ? aptr : reinterpret_cast<char*>( b.getDataArray (auxid) );
      aptr += eltsz * aindex;
      bptr += eltsz * bindex;
 
      TMethodCall* mc = m_assign.call();
      if( mc ) {
 
         // Create a temporary object in memory:
         TClass* eltClass = m_proxy->GetValueClass();
         void* tmp = eltClass->New();
 
         for (size_t i = 0; i < n; ++i) {
           // tmp = a
           mc->ResetParam();
           mc->SetParam( ( Long_t ) aptr );
           mc->Execute( static_cast<void*>( tmp ) );
           // a = b
           mc->ResetParam();
           mc->SetParam( ( Long_t ) bptr );
           mc->Execute( static_cast<void*>( aptr ) );
           // b = tmp
           mc->ResetParam();
           mc->SetParam( ( Long_t ) tmp );
           mc->Execute( static_cast<void*>( bptr ) );
           aptr += eltsz;
           bptr += eltsz;
         }
 
         // Delete the temporary object:
         eltClass->Destructor( tmp );
 
      } else {
 
         // Allocate some temporary memory for the swap:
         std::vector< char > tmp( eltsz*n );
         // tmp = a
         memcpy( tmp.data(), aptr, eltsz*n );
         // a = b
         memcpy( aptr, bptr, eltsz*n );
         // b = tmp
         memcpy( bptr, tmp.data(), eltsz*n );
      }
 
      return;
   }

tiAlloc()

const std::type_info * xAOD::TAuxVectorFactory::tiAlloc ( ) const

overridevirtual

Return the type_info of the vector allocator.

May be nullptr for a dynamic vector.

Implements SG::IAuxTypeVectorFactory.

Definition at line 249 of file TAuxVectorFactory.cxx.

                                                        {
 
      return nullptr;
   }

tiAllocName()

std::string xAOD::TAuxVectorFactory::tiAllocName ( ) const

overridevirtual

Return the (demangled) name of the vector allocator.

Implements SG::IAuxTypeVectorFactory.

Definition at line 254 of file TAuxVectorFactory.cxx.

                                                  {
 
     std::string name = SG::normalizedTypeinfoName (*m_class->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 * xAOD::TAuxVectorFactory::tiVec ( ) const

overridevirtual

Type info of the vector type handled by the factory object.

Implements SG::IAuxTypeVectorFactory.

Definition at line 244 of file TAuxVectorFactory.cxx.

                                                      {
 
      return m_class->GetTypeInfo();
   }

Member Data Documentation

ATLAS_THREAD_SAFE

RootUtils::TSMethodCall m_assign xAOD::TAuxVectorFactory::ATLAS_THREAD_SAFE

mutableprivate

Assignment operator.

Definition at line 115 of file TAuxVectorFactory.h.

m_class

::TClass* xAOD::TAuxVectorFactory::m_class

private

The type that this factory operates on.

Definition at line 111 of file TAuxVectorFactory.h.

m_defElt

void* xAOD::TAuxVectorFactory::m_defElt

private

Pointer to a default element object in memory.

Definition at line 117 of file TAuxVectorFactory.h.

m_proxy

::TVirtualCollectionProxy* xAOD::TAuxVectorFactory::m_proxy

private

ROOT's description of the vector type.

Definition at line 113 of file TAuxVectorFactory.h.

---

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

• TAuxVectorFactory.h
• TAuxVectorFactory.cxx