SG::RootAuxVector Class Reference

Dynamic implementation of IAuxTypeVector, relying on root vector proxy. More...

#include <RootAuxVectorFactory.h>

Inheritance diagram for SG::RootAuxVector:

Collaboration diagram for SG::RootAuxVector:

Public Member Functions
	RootAuxVector (const RootAuxVectorFactory *factory, SG::auxid_t auxid, size_t size, size_t capacity, bool isLinked)
	Constructor.
	RootAuxVector (const RootAuxVectorFactory *factory, SG::auxid_t auxid, void *data, bool isPacked, bool ownFlag, bool isLinked)
	Constructor, from a pointer to a vector object.
	RootAuxVector (const RootAuxVector &other)
	Copy constructor.
RootAuxVector &	operator= (const RootAuxVector &)=delete
virtual	~RootAuxVector () override
	Destructor.
virtual std::unique_ptr< SG::IAuxTypeVector >	clone () const override
	Make a copy of this vector.
virtual void *	toPtr () override
	Return a pointer to the start of the vector's data.
virtual const void *	toPtr () const override
	Return a pointer to the start of the vector's data.
virtual void *	toVector () override
	Return a pointer to the overall object.
virtual size_t	size () const override
	Return the size of the vector.
virtual bool	resize (size_t sz) override
	Change the size of the vector.
virtual void	reserve (size_t sz) override
	Change the capacity of the vector.
virtual bool	shift (size_t pos, ptrdiff_t offs) override
	Shift the elements of the vector.
virtual bool	insertMove (size_t pos, void *src, size_t src_pos, size_t src_n, SG::IAuxStore &srcStore) override
	Insert elements into the vector via move semantics.
virtual const std::type_info *	objType () const override
	Return the type of the complete object to be saved.
virtual void	toTransient (const EventContext &ctx) override
	Perform post-read processing on this auxiliary variable.
virtual bool	setOption (const AuxDataOption &)
	Set an option for this variable.
virtual std::unique_ptr< IAuxTypeVector >	toPacked ()
	Make a packed version of the variable.
virtual std::unique_ptr< IAuxTypeVector >	linkedVector ()
	Return IAuxTypeVector of a linked variable, if there is one.
bool	isLinked () const
	Return true if this variable is linked from another one.
auxid_t	auxid () const
	Return the auxid of the variable this vector represents.
const AuxDataSpanBase &	getDataSpan () const
	Return a reference to a description of this vector's start+size.

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

Private Member Functions
void	storeDataSpan ()
	Update the stored span.

Private Attributes
const RootAuxVectorFactory *	m_factory
	Pointer back to the factory class for this type.
std::unique_ptr< TVirtualCollectionProxy >	m_proxy
	The collection proxy for the vector.
void *	m_obj
	Pointer to the overall object itself.
void *	m_vec
	Pointer to the vector object itself.
bool	m_ownFlag
	Should be delete the vector object?
auxid_t	m_auxid
	The auxid of the variable this vector represents.
bool	m_isLinked
	True if this variable is linked from another one.
CxxUtils::CachedValue< AuxDataSpanBase >	m_span
	Description of the vector start+size.

Detailed Description

Dynamic implementation of IAuxTypeVector, relying on root 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.

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

Definition at line 46 of file RootAuxVectorFactory.h.

Constructor & Destructor Documentation

RootAuxVector() [1/3]

SG::RootAuxVector::RootAuxVector	(	const RootAuxVectorFactory *	factory,
		SG::auxid_t	auxid,
		size_t	size,
		size_t	capacity,
		bool	isLinked )

Constructor.

Makes a new vector.

Parameters

factory	The factory object for this type.
auxid	The auxid of the variable this vector represents.
size	Initial size of the new vector.
capacity	Initial capacity of the new vector.
isLinked	True if this variable is linked from another one.

Definition at line 65 of file RootAuxVectorFactory.cxx.

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

SG::RootAuxVector::RootAuxVector	(	const RootAuxVectorFactory *	factory,
		SG::auxid_t	auxid,
		void *	data,
		bool	isPacked,
		bool	ownFlag,
		bool	isLinked )

Constructor, from a pointer to a vector object.

Parameters

factory	The factory object for this type.
auxid	The auxid of the variable this vector represents.
data	The vector object.
isPacked	If true, data is a PackedContainer.
ownFlag	If true, then 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.

Definition at line 97 of file RootAuxVectorFactory.cxx.

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

SG::RootAuxVector::RootAuxVector

(

const RootAuxVector &

other

)

Copy constructor.

Parameters

other

The vector to copy.

Definition at line 120 of file RootAuxVectorFactory.cxx.

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

SG::RootAuxVector::~RootAuxVector ( )

overridevirtual

Destructor.

This will free the vector data.

Definition at line 145 of file RootAuxVectorFactory.cxx.

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

Member Function Documentation

auxid()

auxid_t SG::IAuxTypeVector::auxid ( ) const

inlineinherited

Return the auxid of the variable this vector represents.

Definition at line 244 of file IAuxTypeVector.h.

  {
    return m_auxid;
  }

clone()

std::unique_ptr< SG::IAuxTypeVector > SG::RootAuxVector::clone ( ) const

overridevirtual

Make a copy of this vector.

Implements SG::IAuxTypeVector.

Definition at line 155 of file RootAuxVectorFactory.cxx.

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

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 273 of file IAuxTypeVector.h.

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

getDataSpanImpl()

AuxDataSpanBase SG::RootAuxVector::getDataSpanImpl ( ) const

finaloverrideprotectedvirtual

Return a span object describing the current vector.

Used to initialize m_span the first time that getDataSpan is called.

Implements SG::IAuxTypeVector.

Definition at line 361 of file RootAuxVectorFactory.cxx.

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

insertMove()

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

overridevirtual

Insert elements into the vector via move semantics.

Parameters

pos	The starting index of the insertion.
src	Start of the vector containing the range of elements to insert.
src_pos	Position of the first element to insert.
src_n	Number of elements to insert.
srcStore	The source store.

The size of the container will be increased by src_n, with the elements starting at pos copied to pos+src_n.

The contents of the source range will then be moved to our vector starting at pos. This will be done via move semantics if possible; otherwise, it will be done with a copy.

Returns true if it is known that the vector's memory did not move, false otherwise.

Implements SG::IAuxTypeVector.

Definition at line 302 of file RootAuxVectorFactory.cxx.

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

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 238 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.

Reimplemented in SG::JaggedVecVectorT< JaggedVecVectorHolder< T, ALLOC > >, SG::PackedLinkVectorT< PackedLinkVectorHolder< CONT, ALLOC > >, and SG::PackedLinkVectorT< PackedLinkVVectorHolder< CONT, VALLOC, VELT, ALLOC > >.

Definition at line 229 of file IAuxTypeVector.h.

{ return nullptr; }

objType()

const std::type_info * SG::RootAuxVector::objType ( ) const

overridevirtual

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 from SG::IAuxTypeVector.

Definition at line 335 of file RootAuxVectorFactory.cxx.

{
  return m_factory->objClass()->GetTypeInfo();
}

operator=()

RootAuxVector & SG::RootAuxVector::operator= ( const RootAuxVector & )

delete

reserve()

void SG::RootAuxVector::reserve ( size_t sz )

overridevirtual

Change the capacity of the vector.

Parameters

sz	The new vector capacity.

Implements SG::IAuxTypeVector.

Definition at line 221 of file RootAuxVectorFactory.cxx.

{
}

resetDataSpan()

void SG::IAuxTypeVector::resetDataSpan ( )

inlineprotectedinherited

Invalidate the stored span.

Definition at line 309 of file IAuxTypeVector.h.

  {
    m_span.reset();
  }

resize()

bool SG::RootAuxVector::resize ( size_t sz )

overridevirtual

Change the size of the vector.

Parameters

sz	The new vector size. Returns true if it is known that iterators have not been invalidated; false otherwise.

Implements SG::IAuxTypeVector.

Definition at line 208 of file RootAuxVectorFactory.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< Elt, typename AuxDataTraits< Elt, ALLOC >::vector_type >, SG::AuxTypeVectorHolder< JaggedVecElt< T >, AuxDataTraits< JaggedVecElt< T >, AuxAllocator_t< JaggedVecElt< T > > >::vector_type >, SG::AuxTypeVectorHolder< JaggedVecElt< T >, AuxDataTraits< JaggedVecElt< T >, VEC::allocator_type >::vector_type >, SG::AuxTypeVectorHolder< PackedLink< CONT >, AuxDataTraits< PackedLink< CONT >, AuxAllocator_t< PackedLink< CONT > > >::vector_type >, SG::AuxTypeVectorHolder< PackedLink< CONT >, typename AuxDataTraits< PackedLink< CONT >, ALLOC >::vector_type >, SG::AuxTypeVectorHolder< PackedLink< TARG >, AuxDataTraits< PackedLink< TARG >, VEC::allocator_type >::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< VELT, typename AuxDataTraits< VELT, ALLOC >::vector_type >.

Definition at line 171 of file IAuxTypeVector.h.

  { return false; }

shift()

bool SG::RootAuxVector::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 252 of file RootAuxVectorFactory.cxx.

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

size()

size_t SG::RootAuxVector::size ( ) const

overridevirtual

Return the size of the vector.

Implements SG::IAuxTypeVector.

Definition at line 196 of file RootAuxVectorFactory.cxx.

{
  return m_proxy->Size();
}

storeDataSpan() [1/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 296 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));
    }
  }

storeDataSpan() [2/2]

void SG::RootAuxVector::storeDataSpan ( )

private

Update the stored span.

Definition at line 371 of file RootAuxVectorFactory.cxx.

{
  IAuxTypeVector::storeDataSpan (this->toPtr(), m_proxy->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< Elt, typename AuxDataTraits< Elt, ALLOC >::vector_type >, SG::AuxTypeVectorHolder< JaggedVecElt< T >, AuxDataTraits< JaggedVecElt< T >, AuxAllocator_t< JaggedVecElt< T > > >::vector_type >, SG::AuxTypeVectorHolder< JaggedVecElt< T >, AuxDataTraits< JaggedVecElt< T >, VEC::allocator_type >::vector_type >, SG::AuxTypeVectorHolder< PackedLink< CONT >, AuxDataTraits< PackedLink< CONT >, AuxAllocator_t< PackedLink< CONT > > >::vector_type >, SG::AuxTypeVectorHolder< PackedLink< CONT >, typename AuxDataTraits< PackedLink< CONT >, ALLOC >::vector_type >, SG::AuxTypeVectorHolder< PackedLink< TARG >, AuxDataTraits< PackedLink< TARG >, VEC::allocator_type >::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< VELT, typename AuxDataTraits< VELT, ALLOC >::vector_type >.

Definition at line 200 of file IAuxTypeVector.h.

{ return 0; }

toPtr() [1/2]

const void * SG::RootAuxVector::toPtr ( ) const

overridevirtual

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

Implements SG::IAuxTypeVector.

Definition at line 175 of file RootAuxVectorFactory.cxx.

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

toPtr() [2/2]

void * SG::RootAuxVector::toPtr ( )

overridevirtual

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

Implements SG::IAuxTypeVector.

Definition at line 164 of file RootAuxVectorFactory.cxx.

{
  if (m_proxy->Size() == 0)
    return 0;
  return m_proxy->At(0);
}

toTransient()

void SG::RootAuxVector::toTransient ( const EventContext & ctx )

overridevirtual

Perform post-read processing on this auxiliary variable.

Parameters

ctx	The current event context.

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.

Implements SG::IAuxTypeVector.

Definition at line 350 of file RootAuxVectorFactory.cxx.

{
  m_factory->toTransient (ctx, *this);
}

toVector()

void * SG::RootAuxVector::toVector ( )

overridevirtual

Return a pointer to the overall object.

Implements SG::IAuxTypeVector.

Definition at line 187 of file RootAuxVectorFactory.cxx.

{
  return m_obj;
}

Member Data Documentation

m_auxid

auxid_t SG::IAuxTypeVector::m_auxid

privateinherited

The auxid of the variable this vector represents.

Definition at line 317 of file IAuxTypeVector.h.

m_factory

const RootAuxVectorFactory* SG::RootAuxVector::m_factory

private

Pointer back to the factory class for this type.

Definition at line 249 of file RootAuxVectorFactory.h.

m_isLinked

bool SG::IAuxTypeVector::m_isLinked

privateinherited

True if this variable is linked from another one.

Definition at line 320 of file IAuxTypeVector.h.

m_obj

void* SG::RootAuxVector::m_obj

private

Pointer to the overall object itself.

Definition at line 258 of file RootAuxVectorFactory.h.

m_ownFlag

bool SG::RootAuxVector::m_ownFlag

private

Should be delete the vector object?

Definition at line 264 of file RootAuxVectorFactory.h.

m_proxy

std::unique_ptr<TVirtualCollectionProxy> SG::RootAuxVector::m_proxy

private

The collection proxy for the vector.

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 255 of file RootAuxVectorFactory.h.

m_span

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

privateinherited

Description of the vector start+size.

Definition at line 323 of file IAuxTypeVector.h.

m_vec

void* SG::RootAuxVector::m_vec

private

Pointer to the vector object itself.

Definition at line 261 of file RootAuxVectorFactory.h.

---

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

• RootAuxVectorFactory.h
• RootAuxVectorFactory.cxx