xAOD::TAuxVector Class Reference

Auxiliary vector type for types known to ROOT. More...

#include <TAuxVector.h>

Inheritance diagram for xAOD::TAuxVector:

Collaboration diagram for xAOD::TAuxVector:

Public Member Functions
	TAuxVector (const TAuxVectorFactory *factory, SG::auxid_t auxid, const ::TClass *cl, size_t size, size_t capacity, bool isLinked)
	Constructor. More...
	TAuxVector (const TAuxVector &parent)
	Copy constructor. More...
	~TAuxVector ()
	Destructor. More...
TAuxVector &	operator= (const TAuxVector &other)
	Assignment operator. More...
virtual bool	setOption (const AuxDataOption &)
	Set an option for this variable. More...
virtual std::unique_ptr< IAuxTypeVector >	toPacked ()
	Make a packed version of the variable. More...
virtual const std::type_info *	objType () const
	Return the type of the complete object to be saved. More...
virtual std::unique_ptr< IAuxTypeVector >	linkedVector ()
	Return IAuxTypeVector of a linked variable, if there is one. More...
bool	isLinked () const
	Return true if this variable is linked from another one. More...
auxid_t	auxid () const
	Return the auxid of the variable this vector represents. More...
const AuxDataSpanBase &	getDataSpan () const
	Return a reference to a description of this vector's start+size. More...
Function implementing the SG::IAuxTypeVector interface
virtual std::unique_ptr< SG::IAuxTypeVector >	clone () const override
	Copy the managed vector. More...
virtual void *	toPtr () override
	Return a pointer to the start of the vector's data. More...
virtual const void *	toPtr () const override
	Return a pointer to the start of the vector's data. More...
virtual void *	toVector () override
	Return a pointer to the STL vector itself. More...
virtual size_t	size () const override
	Return the size of the vector. More...
virtual bool	resize (size_t sz) override
	Change the size of the vector. More...
virtual void	reserve (size_t sz) override
	Change the capacity of the vector. More...
virtual bool	shift (size_t pos, ptrdiff_t offs) override
	Shift the elements of the vector. More...
virtual bool	insertMove (size_t pos, void *src, size_t src_pos, size_t src_n, SG::IAuxStore &srcStore) override
	Insert a range of elements via move. More...

Protected Member Functions
virtual SG::AuxDataSpanBase	getDataSpanImpl () const override final
	Return a span object describing the current vector. More...
void	storeDataSpan ()
	Update the stored span. More...
void	storeDataSpan (void *beg, size_t size)
	Update the stored span. More...
void	resetDataSpan ()
	Invalidate the stored span. More...

Private Member Functions
void	copyRange (const void *src, void *dst, size_t n)
	Function copying the payload of a range to a new location. More...
void	clearRange (void *dst, size_t n)

Private Attributes
const TAuxVectorFactory *	m_factory
	The parent factory object. More...
std::unique_ptr<::TVirtualCollectionProxy >	m_proxy
	ROOT's description of the vector type Cloned from the proxy held by the TClass and permanently bound to m_vec. More...
void *	m_vec
	Pointer to the vector object. More...
auxid_t	m_auxid
	The auxid of the variable this vector represents. More...
bool	m_isLinked
	True if this variable is linked from another one. More...
CxxUtils::CachedValue< AuxDataSpanBase >	m_span
	Description of the vector start+size. More...

Detailed Description

Auxiliary vector type for types known to ROOT.

This class is used for types known to ROOT, which have not received a concrete auxiliary vector type yet. (By having been accessed explicitly.)

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 TAuxVector.h.

Constructor & Destructor Documentation

TAuxVector() [1/2]

xAOD::TAuxVector::TAuxVector	(	const TAuxVectorFactory *	factory,
		SG::auxid_t	auxid,
		const ::TClass *	cl,
		size_t	size,
		size_t	capacity,
		bool	isLinked
	)

Constructor.

Definition at line 20 of file TAuxVector.cxx.

      : 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() [2/2]

xAOD::TAuxVector::TAuxVector

(

const TAuxVector &

parent

)

Copy constructor.

Definition at line 42 of file TAuxVector.cxx.

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

xAOD::TAuxVector::~TAuxVector

(

)

Destructor.

Definition at line 66 of file TAuxVector.cxx.

                           {
 
      m_proxy->Destructor( m_vec );
   }

Member Function Documentation

auxid()

auxid_t SG::IAuxTypeVector::auxid ( ) const

inlineinherited

Return the auxid of the variable this vector represents.

Definition at line 232 of file IAuxTypeVector.h.

  {
    return m_auxid;
  }

clearRange()

void xAOD::TAuxVector::clearRange ( void *  dst, size_t  n  )

private

Definition at line 239 of file TAuxVector.cxx.

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

clone()

std::unique_ptr< SG::IAuxTypeVector > xAOD::TAuxVector::clone ( ) const

overridevirtual

Copy the managed vector.

Implements SG::IAuxTypeVector.

Definition at line 109 of file TAuxVector.cxx.

                                                             {
 
      return std::make_unique< TAuxVector >( *this );
   }

copyRange()

void xAOD::TAuxVector::copyRange ( const void *  src, void *  dst, size_t  n  )

private

Function copying the payload of a range to a new location.

Definition at line 228 of file TAuxVector.cxx.

                                                                    {
 
      SG::AuxVectorInterface idst( auxid(), n, dst );
      m_factory->copy( auxid(),
                       idst, 0,
                       SG::AuxVectorInterface( auxid(), n, src ), 0,
                       n );
 
      return;
   }

getDataSpan()

const AuxDataSpanBase& SG::IAuxTypeVector::getDataSpan ( ) const

inlineinherited

Return a reference to a description of this vector's start+size.

This returns a reference to an AuxDataSpanBase, which gives the start and size of the vector. This object will be updated if the vector changes.

For low overhead, we want this to be a non-virtual function call. However, for variables being read, the usage pattern is that we first create the @IAuxTypeVector object, give the underlying std::vector object to ROOT, and then ROOT fills the vector without the involvement of the IAuxTypeVector. To be able to have this work correctly, we need to defer initializing the span object until the first time that getDataSpan gets called. We do this with a CachedValue. If the span has already been initialized, we just return it; otherwise, we make a virtual call to fetch the vector from the derived class.

Be aware: this is in principle a const-correctness violation, since AuxDataSpanBase has a non-const pointer to the start of the vector. But doing it properly is kind of painful, and as this interface is only meant to be used internally, it's likely not a real problem.

Definition at line 261 of file IAuxTypeVector.h.

  {
    if (!m_span.isValid()) {
      m_span.set (this->getDataSpanImpl());
    }
    return *m_span.ptr();
  }

getDataSpanImpl()

SG::AuxDataSpanBase xAOD::TAuxVector::getDataSpanImpl ( ) const

finaloverrideprotectedvirtual

Return a span object describing the current vector.

Implements SG::IAuxTypeVector.

Definition at line 256 of file TAuxVector.cxx.

   {
     return SG::AuxDataSpanBase( const_cast<void*> (toPtr()), size() );
   }

insertMove()

bool xAOD::TAuxVector::insertMove ( size_t  pos, void *  src, size_t  src_pos, size_t  src_n, SG::IAuxStore &  srcStore  )

overridevirtual

Insert a range of elements via move.

Implements SG::IAuxTypeVector.

Definition at line 206 of file TAuxVector.cxx.

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

isLinked()

bool SG::IAuxTypeVector::isLinked ( ) const

inlineinherited

Return true if this variable is linked from another one.

This is inlined here rather than being a virtual function because this is frequently called from loops over auxids.

Definition at line 226 of file IAuxTypeVector.h.

{ return m_isLinked; }

linkedVector()

virtual std::unique_ptr<IAuxTypeVector> SG::IAuxTypeVector::linkedVector ( )

inlinevirtualinherited

Return IAuxTypeVector of a linked variable, if there is one.

If the variable represented by this vector has a linked variable, then return its IAuxTypeVector. Otherwise, return nullptr. Beware of potential threading issues: the returned object is not locked, so it should not be modified in contexts where the parent container cannot be modified.

This returns a unique_ptr, so it can generally be called only once on a given instance. After that, it will return nullptr.

Definition at line 217 of file IAuxTypeVector.h.

{ return nullptr; }

objType()

virtual const std::type_info* SG::IAuxTypeVector::objType ( ) const

inlinevirtualinherited

Return the type of the complete object to be saved.

For example, if the object is a std::vector, then we return the type_info of the vector. But if we're holding a PackedContainer, then we return the type_info of the PackedContainer.

Can return null if the operation is not supported. In that case, I/O will use the type found from the variable registry.

Reimplemented in SG::RootAuxVector, SG::AuxTypeVectorHolder< T, CONT >, and xAOD::AuxPersInfo< T >.

Definition at line 202 of file IAuxTypeVector.h.

{ return 0; }

operator=()

TAuxVector & xAOD::TAuxVector::operator=

(

const TAuxVector &

other

)

Assignment operator.

Definition at line 71 of file TAuxVector.cxx.

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

reserve()

void xAOD::TAuxVector::reserve ( size_t  sz )

overridevirtual

Change the capacity of the vector.

Implements SG::IAuxTypeVector.

Definition at line 143 of file TAuxVector.cxx.

                                    {
 
      return;
   }

resetDataSpan()

void SG::IAuxTypeVector::resetDataSpan ( )

inlineprotectedinherited

Invalidate the stored span.

Definition at line 297 of file IAuxTypeVector.h.

  {
    m_span.reset();
  }

resize()

bool xAOD::TAuxVector::resize ( size_t  sz )

overridevirtual

Change the size of the vector.

Implements SG::IAuxTypeVector.

Definition at line 135 of file TAuxVector.cxx.

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

setOption()

virtual bool SG::IAuxTypeVector::setOption ( const AuxDataOption &  )

inlinevirtualinherited

Set an option for this variable.

Parameters

option

The option to set.

The interpretation of the option depends on the particular representation of the variable provided by the concrete class.

Returns true if the option setting was successful; false otherwise.

Reimplemented in SG::AuxTypeVectorHolder< T, CONT >, SG::AuxTypeVectorHolder< JaggedVecElt< T >, AuxDataTraits< JaggedVecElt< T >, VEC::allocator_type >::vector_type >, SG::AuxTypeVectorHolder< PackedLink< TARG >, AuxDataTraits< PackedLink< TARG >, VEC::allocator_type >::vector_type >, SG::AuxTypeVectorHolder< PackedLink< CONT >, AuxDataTraits< PackedLink< CONT >, AuxAllocator_t< PackedLink< CONT > > >::vector_type >, SG::AuxTypeVectorHolder< std::vector< SG::PackedLink< TARG >, VALLOC >, AuxDataTraits< std::vector< SG::PackedLink< TARG >, VALLOC >, VEC::allocator_type >::vector_type >, SG::AuxTypeVectorHolder< T, std::vector< T > >, SG::AuxTypeVectorHolder< typename AuxDataTraits< PackedLink< CONT >, AuxAllocator_t< PackedLink< CONT > > >::vector_type, AuxDataTraits< typename AuxDataTraits< PackedLink< CONT >, AuxAllocator_t< PackedLink< CONT > > >::vector_type, AuxAllocator_t< typename AuxDataTraits< PackedLink< CONT >, AuxAllocator_t< PackedLink< CONT > > >::vector_type > >::vector_type >, and SG::AuxTypeVectorHolder< JaggedVecElt< T >, AuxDataTraits< JaggedVecElt< T >, AuxAllocator_t< JaggedVecElt< T > > >::vector_type >.

Definition at line 172 of file IAuxTypeVector.h.

  { return false; }

shift()

bool xAOD::TAuxVector::shift ( size_t  pos, ptrdiff_t  offs  )

overridevirtual

Shift the elements of the vector.

Parameters

pos	The starting index for the shift.
offs	The (signed) amount of the shift.

This operation shifts the elements in the vectors for all aux data items, to implement an insertion or deletion. offs may be either positive or negative.

If offs is positive, then the container is growing. The container size should be increased by offs, the element at pos moved to pos + offs, and similarly for following elements. The elements between pos and pos + offs should be default-initialized.

If offs is negative, then the container is shrinking. The element at pos should be moved to pos + offs, and similarly for following elements. The container should then be shrunk by -offs elements (running destructors as appropriate).

Returns true if it is known that iterators have not been invalidated; false otherwise. (Will always return false when increasing the size of an empty container.)

Implements SG::IAuxTypeVector.

Definition at line 174 of file TAuxVector.cxx.

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

size()

size_t xAOD::TAuxVector::size ( ) const

overridevirtual

Return the size of the vector.

Implements SG::IAuxTypeVector.

Definition at line 130 of file TAuxVector.cxx.

                                 {
 
      return m_proxy->Size();
   }

storeDataSpan() [1/2]

void xAOD::TAuxVector::storeDataSpan ( )

protected

Update the stored span.

Definition at line 261 of file TAuxVector.cxx.

   {
     IAuxTypeVector::storeDataSpan( toPtr(), size() );
   }

storeDataSpan() [2/2]

void SG::IAuxTypeVector::storeDataSpan ( void *  beg, size_t  size  )

inlineprotectedinherited

Update the stored span.

Parameters

beg	The start of the vector.
size	The length of the vector.

Definition at line 284 of file IAuxTypeVector.h.

  {
    // Only do this if the span is already valid, so that it doesn't
    // get marked valid before ROOT I/O.
    if (m_span.isValid()) {
      m_span.store (AuxDataSpanBase (beg, size));
    }
  }

toPacked()

virtual std::unique_ptr<IAuxTypeVector> SG::IAuxTypeVector::toPacked ( )

inlinevirtualinherited

Make a packed version of the variable.

If possible, return a new vector object that stores the data in a PackedContainer. The data itself should be moved to the new container (so that this vector becomes empty). This ensures that pointers to the data are preserved.

If successful, a newly-allocated object is returned. A null pointer is returned on failure (operation not supported, type can't be packed, type is already packed).

Reimplemented in SG::AuxTypeVectorHolder< T, CONT >, SG::AuxTypeVectorHolder< JaggedVecElt< T >, AuxDataTraits< JaggedVecElt< T >, VEC::allocator_type >::vector_type >, SG::AuxTypeVectorHolder< PackedLink< TARG >, AuxDataTraits< PackedLink< TARG >, VEC::allocator_type >::vector_type >, SG::AuxTypeVectorHolder< PackedLink< CONT >, AuxDataTraits< PackedLink< CONT >, AuxAllocator_t< PackedLink< CONT > > >::vector_type >, SG::AuxTypeVectorHolder< std::vector< SG::PackedLink< TARG >, VALLOC >, AuxDataTraits< std::vector< SG::PackedLink< TARG >, VALLOC >, VEC::allocator_type >::vector_type >, SG::AuxTypeVectorHolder< T, std::vector< T > >, SG::AuxTypeVectorHolder< typename AuxDataTraits< PackedLink< CONT >, AuxAllocator_t< PackedLink< CONT > > >::vector_type, AuxDataTraits< typename AuxDataTraits< PackedLink< CONT >, AuxAllocator_t< PackedLink< CONT > > >::vector_type, AuxAllocator_t< typename AuxDataTraits< PackedLink< CONT >, AuxAllocator_t< PackedLink< CONT > > >::vector_type > >::vector_type >, and SG::AuxTypeVectorHolder< JaggedVecElt< T >, AuxDataTraits< JaggedVecElt< T >, AuxAllocator_t< JaggedVecElt< T > > >::vector_type >.

Definition at line 188 of file IAuxTypeVector.h.

{ return 0; }

toPtr() [1/2]

const void * xAOD::TAuxVector::toPtr ( ) const

overridevirtual

Return a pointer to the start of the vector's data.

Implements SG::IAuxTypeVector.

Definition at line 120 of file TAuxVector.cxx.

                                       {
 
      return m_proxy->At( 0 );
   }

toPtr() [2/2]

void * xAOD::TAuxVector::toPtr ( )

overridevirtual

Return a pointer to the start of the vector's data.

Implements SG::IAuxTypeVector.

Definition at line 115 of file TAuxVector.cxx.

                           {
 
      return m_proxy->At( 0 );
   }

toVector()

void * xAOD::TAuxVector::toVector ( )

overridevirtual

Return a pointer to the STL vector itself.

Implements SG::IAuxTypeVector.

Definition at line 125 of file TAuxVector.cxx.

                              {
 
      return m_vec;
   }

Member Data Documentation

m_auxid

auxid_t SG::IAuxTypeVector::m_auxid

privateinherited

The auxid of the variable this vector represents.

Definition at line 305 of file IAuxTypeVector.h.

m_factory

const TAuxVectorFactory* xAOD::TAuxVector::m_factory

private

The parent factory object.

Definition at line 89 of file TAuxVector.h.

m_isLinked

bool SG::IAuxTypeVector::m_isLinked

privateinherited

True if this variable is linked from another one.

Definition at line 308 of file IAuxTypeVector.h.

m_proxy

std::unique_ptr<::TVirtualCollectionProxy> xAOD::TAuxVector::m_proxy

private

ROOT's description of the vector type Cloned from the proxy held by the TClass and permanently bound to m_vec.

That makes things a bit more efficient, and prevents potential thread-safety problems.

Definition at line 94 of file TAuxVector.h.

m_span

CxxUtils::CachedValue<AuxDataSpanBase> SG::IAuxTypeVector::m_span

privateinherited

Description of the vector start+size.

Definition at line 311 of file IAuxTypeVector.h.

m_vec

void* xAOD::TAuxVector::m_vec

private

Pointer to the vector object.

Definition at line 96 of file TAuxVector.h.

---

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

• TAuxVector.h
• TAuxVector.cxx