Derived DataVector<T>. More...

#include <DataVector.h>

Inheritance diagram for DataVector< T, BASE >:

Collaboration diagram for DataVector< T, BASE >:

Public Types
typedef BASE	DataVector_BASE

typedef BASE	DVL_BASE

typedef BASE::PtrVector	PtrVector
	This is the type of the underlying `std::vector` (what `stdcont` returns). More...

typedef BASE::PtrVector	BaseContainer

typedef T *&	reference

typedef T *const &	const_reference

typedef BASE::size_type	size_type

typedef BASE::difference_type	difference_type

typedef T *	value_type

typedef BASE::allocator_type	allocator_type

typedef T **	pointer

typedef T const	const_pointer

typedef const T *	const_value_type

typedef T	base_value_type
	The `T` value used as the template parameter. More...

typedef std::unique_ptr< base_value_type >	unique_type
	Type of a unique_ptr that can be used to insert elements into this container. More...

typedef DataModel_detail::ElementProxy< DataVector >	ElementProxy
	This type is used to proxy lvalue accesses to `DataVector` elements, in order to handle ownership. More...

typedef DataModel_detail::const_iterator< DataVector >	const_iterator
	Standard `const_iterator`. More...

typedef DataModel_detail::iterator< DataVector >	iterator
	Standard `iterator`. More...

typedef std::reverse_iterator< const_iterator >	const_reverse_iterator
	Standard `const_reverse_iterator`. More...

typedef std::reverse_iterator< iterator >	reverse_iterator
	Standard `reverse_iterator`. More...

typedef DataVector	base_data_vector

using	Deleter = typename BASE::Deleter

typedef DataVector< T, BASE >	self
	A helper typedef. More...

Public Attributes
ROOT_SELECTION_NS::MemberAttributes< kTransient >	m_isMostDerived
	Automatically generate dictionary for contained vector. More...

ROOT_SELECTION_NS::MemberAttributes< kTransient >	m_deleter

ROOT_SELECTION_NS::MemberAttributes< kTransient >	m_ownPolicy
	We do not want to save this. More...

Static Public Attributes
static const bool	has_virtual = BASE::has_virtual
	This is true for any `DataVector` class if we need to use virtual derivation to get to the base `DataVector` class. More...

static constexpr bool	must_own = BASE::must_own
	If true, then this type must own its contents. More...

Constructors, destructors, assignment.
	DataVector (SG::OwnershipPolicy ownPolicy=SG::OWN_ELEMENTS, SG::IndexTrackingPolicy trackIndices=SG::DEFAULT_TRACK_INDICES)
	Default constructor. More...

	DataVector (size_type n, SG::OwnershipPolicy ownPolicy=SG::OWN_ELEMENTS, SG::IndexTrackingPolicy trackIndices=SG::DEFAULT_TRACK_INDICES)
	Sized constructor. More...

	DataVector (const DataVector &)=default
	Copy constructor. More...

	DataVector (DataVector &&rhs) noexcept
	Move constructor. More...

template<class InputIterator >
	DataVector (InputIterator first, InputIterator last, SG::OwnershipPolicy ownPolicy=SG::VIEW_ELEMENTS, SG::IndexTrackingPolicy trackIndices=SG::DEFAULT_TRACK_INDICES, SG::IAuxStore *store=0)
	Constructor from iterators. More...

	DataVector (std::initializer_list< value_type > l, SG::OwnershipPolicy ownPolicy=SG::VIEW_ELEMENTS, SG::IndexTrackingPolicy trackIndices=SG::DEFAULT_TRACK_INDICES, SG::IAuxStore *store=0)
	Constructor from an initializer list. More...

DataVector &	operator= (const DataVector &rhs)
	Assignment operator. More...

DataVector &	operator= (DataVector &&rhs) noexcept
	Move assignment. More...

DataVector &	operator= (std::initializer_list< value_type > l)
	Assignment operator, from an initializer list. More...

template<class InputIterator >
void	assign (InputIterator first, InputIterator last)
	Assign from iterators. More...

void	assign (std::initializer_list< value_type > l)

Swap and sort.
void	swap (DataVector &rhs)
	Swap this collection with another. More...

void	sort ()
	Sort the container. More...

template<class COMPARE >
void	sort (COMPARE comp)
	Sort the container with a user-specified comparison operator. More...

static void	iter_swap (iterator a, iterator b)
	Swap the referents of two `DataVector` iterators. More...

Non-standard operations.
void	swapElement (size_type index, value_type newElem, reference oldElem)
	Swap one element out of the container. More...

void	swapElement (iterator pos, value_type newElem, reference oldElem)
	Swap one element out of the container. More...

void	swapElement (size_type index, std::unique_ptr< base_value_type > newElem, std::unique_ptr< base_value_type > &oldElem)
	Swap one element out of the container. More...

void	swapElement (iterator pos, std::unique_ptr< base_value_type > newElem, std::unique_ptr< base_value_type > &oldElem)
	Swap one element out of the container. More...

void	clear (SG::OwnershipPolicy ownPolicy)
	Erase all the elements in the collection, and reset the ownership mode. More...

void	clear (SG::OwnershipPolicy ownPolicy, SG::IndexTrackingPolicy trackIndices)

void	clear (std::unique_ptr< Deleter > deleter)
	Erase all the elements in the collection, and change how elements are to be deleted. More...

virtual const DataModel_detail::DVLInfoBase &	dvlinfo_v () const
	Return the DV/DL info struct for this class. More...

const SG::AuxVectorBase &	auxbase () const
	Convert to `AuxVectorBase`. More...

size_type	max_size () const noexcept
	Returns the `size()` of the largest possible collection. More...

void	resize (size_type sz)

size_type	capacity () const noexcept
	Returns the total number of elements that the collection can hold before needing to allocate more memory. More...

bool	empty () const noexcept
	Returns `true` if the collection is empty. More...

void	shrink_to_fit ()

void	pop_back ()

void	clear ()

const PtrVector &	stdcont () const
	Return the underlying `std::vector` of the container. More...

SG::OwnershipPolicy	ownPolicy () const
	Return the ownership policy setting for this container. More...

void	clear (SG::OwnershipPolicy ownPolicy, SG::IndexTrackingPolicy trackIndices=SG::DEFAULT_TRACK_INDICES)

static const DataModel_detail::DVLInfoBase &	dvlinfo ()
	Return the DV/DL info struct for this class. More...

static int	baseOffset (const std::type_info &ti)
	Return the offset of a base `DataVector` class. More...

Internal operations.
typedef ROOT_SELECTION_NS::DataVector< T, DataVector_BASE >::self	self

class	DataModel_detail::ElementProxy< DataVector >

template<class DV >
class	ConstDataVector

template<class DV , class ALLOC >
class	DataVectorWithAlloc

void	test2_assignelement1a ()

void	test2_assignelement1 ()

void	test2_assignelement2 ()

SG::IsMostDerivedFlag	m_isMostDerived
	This flag is true if this DV instance is the most-derived one. More...

void	resortAux (iterator beg, iterator end)
	Reset indices / reorder aux data after elements have been permuted. More...

void	testInsert (const char *op)
	Test if we can insert; raise an exception if not. More...

void	testInsertOol (const char *op)
	Test if we can insert; raise an exception if not. More...

static int	baseOffset1 (const char *p, const DataVector &dv, const std::type_info &ti)
	Helper for `baseOffset`. More...

static const T *	do_cast (const typename PtrVector::value_type p)
	Helper to shorten calls to `DataModel_detail::DVLCast`. More...

static T *	do_cast_nc (typename PtrVector::value_type p)
	Helper to shorten calls to `DataModel_detail::DVLCast`. More...

void	assignElement (typename BaseContainer::iterator pos, value_type newElem)
	Handle element assignment. More...

void	assignElement (typename BaseContainer::iterator pos, std::unique_ptr< base_value_type > newElem)
	Handle element assignment. More...

void	assignBaseElement (typename BaseContainer::iterator pos, typename BaseContainer::value_type newElem)
	Handle element assignment from a base pointer. More...

void	shift (size_t pos, ptrdiff_t offs)
	Shift the auxiliary elements of the container. More...

virtual const std::type_info &	dv_typeid () const
	Find the most-derived `DataVector` class in the hierarchy. More...

void	clearMostDerived ()
	Clear `m_isMostDerived` for this instance and for all bases. More...

virtual void	setMostDerived ()
	Set `m_isMostDerived` for this instance and clear it for all bases. More...

Detailed Description

template<class T, class BASE>
class DataVector< T, BASE >

Derived DataVector<T>.

This is used for the case where T derives from other classes. The vector of pointers is actually held in the (unique) base class of the hierarchy.

See the file comments for full details.

Definition at line 581 of file DataVector.h.

Member Typedef Documentation

◆ allocator_type

template<class T , class BASE >

typedef BASE::allocator_type DataVector< T, BASE >::allocator_type

Definition at line 816 of file DataVector.h.

◆ base_data_vector

template<class T , class BASE >

typedef DataVector DataVector< T, BASE >::base_data_vector

Definition at line 853 of file DataVector.h.

◆ base_value_type

template<class T , class BASE >

typedef T DataVector< T, BASE >::base_value_type

The T value used as the template parameter.

Note that this is different from value_type (that's T*).

Definition at line 824 of file DataVector.h.

◆ BaseContainer

template<class T , class BASE >

typedef BASE::PtrVector DataVector< T, BASE >::BaseContainer

Definition at line 806 of file DataVector.h.

◆ const_iterator

template<class T , class BASE >

typedef DataModel_detail::const_iterator<DataVector> DataVector< T, BASE >::const_iterator

Standard const_iterator.

Definition at line 837 of file DataVector.h.

◆ const_pointer

template<class T , class BASE >

typedef T* const* DataVector< T, BASE >::const_pointer

Definition at line 818 of file DataVector.h.

◆ const_reference

template<class T , class BASE >

typedef T* const& DataVector< T, BASE >::const_reference

Definition at line 812 of file DataVector.h.

◆ const_reverse_iterator

template<class T , class BASE >

typedef std::reverse_iterator<const_iterator> DataVector< T, BASE >::const_reverse_iterator

Standard const_reverse_iterator.

Definition at line 846 of file DataVector.h.

◆ const_value_type

template<class T , class BASE >

typedef const T* DataVector< T, BASE >::const_value_type

Definition at line 820 of file DataVector.h.

◆ DataVector_BASE

template<class T , class BASE >

typedef BASE DataVector< T, BASE >::DataVector_BASE

Definition at line 796 of file DataVector.h.

◆ Deleter

template<class T , class BASE >

using DataVector< T, BASE >::Deleter = typename BASE::Deleter

Definition at line 856 of file DataVector.h.

◆ difference_type

template<class T , class BASE >

typedef BASE::difference_type DataVector< T, BASE >::difference_type

Definition at line 814 of file DataVector.h.

◆ DVL_BASE

template<class T , class BASE >

typedef BASE DataVector< T, BASE >::DVL_BASE

Definition at line 797 of file DataVector.h.

◆ ElementProxy

template<class T , class BASE >

typedef DataModel_detail::ElementProxy<DataVector> DataVector< T, BASE >::ElementProxy

This type is used to proxy lvalue accesses to DataVector elements, in order to handle ownership.

Definition at line 832 of file DataVector.h.

◆ iterator

template<class T , class BASE >

typedef DataModel_detail::iterator<DataVector> DataVector< T, BASE >::iterator

Standard iterator.

Note that lvalue references here will yield an ElementProxy, not a reference.

Definition at line 841 of file DataVector.h.

◆ pointer

template<class T , class BASE >

typedef T** DataVector< T, BASE >::pointer

Definition at line 817 of file DataVector.h.

◆ PtrVector

template<class T , class BASE >

typedef BASE::PtrVector DataVector< T, BASE >::PtrVector

This is the type of the underlying std::vector (what stdcont returns).

Definition at line 805 of file DataVector.h.

◆ reference

template<class T , class BASE >

typedef T*& DataVector< T, BASE >::reference

Definition at line 811 of file DataVector.h.

◆ reverse_iterator

template<class T , class BASE >

typedef std::reverse_iterator<iterator> DataVector< T, BASE >::reverse_iterator

Standard reverse_iterator.

Note that lvalue references here will yield an ElementProxy, not a reference.

Definition at line 851 of file DataVector.h.

◆ self [1/2]

template<class T , class BASE >

typedef ROOT_SELECTION_NS::DataVector<T, DataVector_BASE>::self DataVector< T, BASE >::self

private

Definition at line 2042 of file DataVector.h.

◆ self [2/2]

template<class T , class BASE >

typedef DataVector< T, BASE > DataVector< T, BASE >::self

A helper typedef.

Definition at line 3428 of file DataVector.h.

◆ size_type

template<class T , class BASE >

typedef BASE::size_type DataVector< T, BASE >::size_type

Definition at line 813 of file DataVector.h.

◆ unique_type

template<class T , class BASE >

typedef std::unique_ptr<base_value_type> DataVector< T, BASE >::unique_type

Type of a unique_ptr that can be used to insert elements into this container.

Definition at line 828 of file DataVector.h.

◆ value_type

template<class T , class BASE >

typedef T* DataVector< T, BASE >::value_type

Definition at line 815 of file DataVector.h.

Constructor & Destructor Documentation

◆ DataVector() [1/6]

template<class T , class BASE >

DataVector< T, BASE >::DataVector	(	SG::OwnershipPolicy	ownPolicy = `SG::OWN_ELEMENTS`,
		SG::IndexTrackingPolicy	trackIndices = `SG::DEFAULT_TRACK_INDICES`
	)

explicit

Default constructor.

Parameters

ownPolicy	The ownership mode for the container.
trackIndices	The index tracking policy.

By default, a DataVector will own its elements. To avoid this, pass SG::VIEW_ELEMENTS for ownPolicy.

◆ DataVector() [2/6]

template<class T , class BASE >

DataVector< T, BASE >::DataVector	(	size_type	n,
		SG::OwnershipPolicy	ownPolicy = `SG::OWN_ELEMENTS`,
		SG::IndexTrackingPolicy	trackIndices = `SG::DEFAULT_TRACK_INDICES`
	)

explicit

Sized constructor.

Parameters

n	The size of the container.
ownPolicy	The ownership mode for the container.
trackIndices	The index tracking policy.

Note that unlike the standard vector constructor, you can't specify an initial value here. The container will be initialized with 0's.

By default, a DataVector will own its elements. To avoid this, pass SG::VIEW_ELEMENTS for ownPolicy.

◆ DataVector() [3/6]

template<class T , class BASE >

DataVector< T, BASE >::DataVector ( const DataVector< T, BASE > & )

default

Copy constructor.

Parameters

rhs	The container from which to copy.

This is a ‘shallow’ copy; the new container will not own its elements.

◆ DataVector() [4/6]

template<class T , class BASE >

DataVector< T, BASE >::DataVector ( DataVector< T, BASE > && rhs )

noexcept

Move constructor.

Parameters

rhs	The container from which to move.

Any auxiliary data will be moved along with the container contents.

◆ DataVector() [5/6]

template<class T , class BASE >

template<class InputIterator >

DataVector< T, BASE >::DataVector	(	InputIterator	first,
		InputIterator	last,
		SG::OwnershipPolicy	ownPolicy = `SG::VIEW_ELEMENTS`,
		SG::IndexTrackingPolicy	trackIndices = `SG::DEFAULT_TRACK_INDICES`,
		SG::IAuxStore *	store = `0`
	)

Constructor from iterators.

Parameters

first	The start of the range to put in the new container.
last	The end of the range to put in the new container.
ownPolicy	The ownership mode for the container.
trackIndices	The index tracking policy.
store	An associated auxiliary data store.

By default, a view container is made, which does not own its elements. To have the container take ownership of the pointers passed to this constructor, pass SG::OWN_ELEMENTS for ownPolicy.

◆ DataVector() [6/6]

template<class T , class BASE >

DataVector< T, BASE >::DataVector	(	std::initializer_list< value_type >	l,
		SG::OwnershipPolicy	ownPolicy = `SG::VIEW_ELEMENTS`,
		SG::IndexTrackingPolicy	trackIndices = `SG::DEFAULT_TRACK_INDICES`,
		SG::IAuxStore *	store = `0`
	)

Constructor from an initializer list.

Parameters

l	An initializer list.
ownPolicy	The ownership mode for the container.
trackIndices	The index tracking policy.
store	An associated auxiliary data store.

A DataVector constructed this way will not own its elements by default. To change this, pass SG::OWN_ELEMENTS for ownPolicy.

Member Function Documentation

◆ assign() [1/2]

template<class T , class BASE >

template<class InputIterator >

void DataVector< T, BASE >::assign	(	InputIterator	first,
		InputIterator	last
	)

Assign from iterators.

Parameters

first	The start of the range to put in the container.
last	The end of the range to put in the container.

Any existing owned elements will be released. The DataVector's ownership policy determines whether it will take ownership of the new elements.

◆ assign() [2/2]

template<class T , class BASE >

void DataVector< T, BASE >::assign ( std::initializer_list< value_type > l )

Parameters

l	An initializer list.

Any existing owned elements will be released. The DataVector's ownership policy determines whether it will take ownership of the new elements.

◆ assignBaseElement()

template<class T , class BASE >

void DataVector< T, BASE >::assignBaseElement	(	typename BaseContainer::iterator	pos,
		typename BaseContainer::value_type	newElem
	)

private

Handle element assignment from a base pointer.

Parameters

pos	Position in the container to assign.
newElem	The new element to assign.

The old element is freed if this container owns elements. Auxiliary data are copied if appropriate.

◆ assignElement() [1/2]

template<class T , class BASE >

void DataVector< T, BASE >::assignElement	(	typename BaseContainer::iterator	pos,
		std::unique_ptr< base_value_type >	newElem
	)

private

Handle element assignment.

Parameters

pos	Position in the container to assign.
newElem	The new element to assign.

The container must own its elements. Auxiliary data are copied if appropriate.

◆ assignElement() [2/2]

template<class T , class BASE >

void DataVector< T, BASE >::assignElement	(	typename BaseContainer::iterator	pos,
		value_type	newElem
	)

private

Handle element assignment.

Parameters

pos	Position in the container to assign.
newElem	The new element to assign.

The old element is freed if this container owns elements. Auxiliary data are copied if appropriate.

◆ at() [1/2]

template<class T , class BASE >

ElementProxy DataVector< T, BASE >::at ( size_type n )

Access an element, as an lvalue.

Parameters

n	Array index to access.

Returns: Proxy to the element at n.

Will raise std::out_of_range if the index is out-of-bounds. Note that we return a proxy object rather than a reference; the proxy will handle deleting an owned element if it's assigned to.

◆ at() [2/2]

template<class T , class BASE >

const T* DataVector< T, BASE >::at ( size_type n ) const

Access an element, as an rvalue.

Parameters

n	Array index to access.

Returns: The element at n.

Will raise std::out_of_range if the index is out-of-bounds. Note that we return a const T* rather than a reference.

◆ auxbase()

template<class T , class BASE >

const SG::AuxVectorBase& DataVector< T, BASE >::auxbase ( ) const

Convert to AuxVectorBase.

Needed to get AuxVectorBase from a ConstDataVector. Present in DataVector as well for consistency. We only really need it in the base class; however, root6 fails constructing a TMethodCall for this if there is virtual derivation. A workaround is to redeclare this in the derived classes too.

◆ back() [1/2]

template<class T , class BASE >

ElementProxy DataVector< T, BASE >::back ( )

Access the last element in the collection as an lvalue.

Returns: Proxy to the last element in the collection.

No checking is done to ensure that the container is not empty. Note that we return a proxy object rather than a reference; the proxy will handle deleting an owned element if it's assigned to.

◆ back() [2/2]

template<class T , class BASE >

const T* DataVector< T, BASE >::back ( ) const

Access the last element in the collection as an rvalue.

Returns: The last element in the collection.

No checking is done to ensure that the container is not empty. Note that we return a const T* rather than a reference.

◆ baseOffset()

template<class T , class BASE >

static int DataVector< T, BASE >::baseOffset ( const std::type_info & ti )

static

Return the offset of a base DataVector class.

Parameters

ti	`std::type_info` of the desired class.

If ti represents a DataVector base class of this one, then return the offset of that base class. Otherwise, return -1.

This function is here due to limitations of root 6, which can't calculate these offsets correctly from the dictionary if virtual derivation is used.

◆ baseOffset1()

template<class T , class BASE >

static int DataVector< T, BASE >::baseOffset1	(	const char *	p,
		const DataVector< T, BASE > &	dv,
		const std::type_info &	ti
	)

static

Helper for baseOffset.

Parameters

p	Pointer to the start of the top-level object.
dv	Reference to the DataVector object.
ti	`std::type_info` of the desired class.

If ti represents a DataVector base class of this one, then return the offset of that base class. Otherwise, return -1.

◆ begin() [1/2]

template<class T , class BASE >

const_iterator DataVector< T, BASE >::begin ( ) const

noexcept

Return a const_iterator pointing at the beginning of the collection.

Returns: A const_iterator.

Note that dereferencing the iterator will yield a const T* rather than a reference.

◆ begin() [2/2]

template<class T , class BASE >

iterator DataVector< T, BASE >::begin ( )

noexcept

Return an iterator pointing at the beginning of the collection.

Returns: An iterator.

Note that dereferencing the iterator will yield a proxy rather than a reference; the proxy will handle deleting an owned element if it's assigned to.

◆ capacity()

template<class T , class BASE >

size_type DataVector< T, BASE >::capacity ( ) const

noexcept

Returns the total number of elements that the collection can hold before needing to allocate more memory.

◆ cbegin()

template<class T , class BASE >

const_iterator DataVector< T, BASE >::cbegin ( ) const

noexcept

Return a const_iterator pointing at the beginning of the collection.

Returns: A const_iterator.

Note that dereferencing the iterator will yield a const T* rather than a reference.

◆ cend()

template<class T , class BASE >

const_iterator DataVector< T, BASE >::cend ( ) const

noexcept

Return a const_iterator pointing past the end of the collection.

Returns: A const_iterator.

Note that dereferencing the iterator will yield a const T* rather than a reference.

◆ clear() [1/6]

template<class T , class BASE >

void DataVector< T, BASE >::clear ( )

Erase all the elements in the collection.

Erase all the elements in the collection, and reset the ownership mode.

If the container owns its elements, then the removed elements will be deleted. Any duplicates will be removed in this process, but don't rely on this.

Parameters

ownPolicy	The new ownership policy of the container.
trackIndices	The index tracking policy.

If the container owns its elements, then the removed elements will be deleted. Any duplicates will be removed in this process, but don't rely on this.

◆ clear() [2/6]

template<class T , class BASE >

void DataVector< T, BASE >::clear ( )

◆ clear() [3/6]

template<class T , class BASE >

void DataVector< T, BASE >::clear ( SG::OwnershipPolicy ownPolicy )

Erase all the elements in the collection, and reset the ownership mode.

Parameters

ownPolicy The new ownership policy of the container.

If the container owns its elements, then the removed elements will be deleted. Any duplicates will be removed in this process, but don't rely on this.

◆ clear() [4/6]

template<class T , class BASE >

void DataVector< T, BASE >::clear	(	SG::OwnershipPolicy	ownPolicy,
		SG::IndexTrackingPolicy	trackIndices
	)

◆ clear() [5/6]

template<class T , class BASE >

void DataVector< T, BASE >::clear	(	SG::OwnershipPolicy	ownPolicy,
		SG::IndexTrackingPolicy	trackIndices = `SG::DEFAULT_TRACK_INDICES`
	)

◆ clear() [6/6]

template<class T , class BASE >

void DataVector< T, BASE >::clear ( std::unique_ptr< Deleter > deleter )

Erase all the elements in the collection, and change how elements are to be deleted.

Parameters

deleter Object to be used to delete object. Passing nullptr will change back to the default.

If the container owns its elements, then the removed elements will be deleted. Any duplicates will be removed in this process, but don't rely on this. After the current elements are deleted, the Deleter object is changed.

◆ clearMostDerived()

template<class T , class BASE >

void DataVector< T, BASE >::clearMostDerived ( )

protected

Clear m_isMostDerived for this instance and for all bases.

Called from the constructor after setting m_isMostDerived.

◆ crbegin()

template<class T , class BASE >

const_reverse_iterator DataVector< T, BASE >::crbegin ( ) const

noexcept

Return a const_reverse_iterator pointing past the end of the collection.

Returns: A const_reverse_iterator.

Note that dereferencing the iterator will yield a const T* rather than a reference.

◆ crend()

template<class T , class BASE >

const_reverse_iterator DataVector< T, BASE >::crend ( ) const

noexcept

Return a const_reverse_iterator pointing at the beginning of the collection.

Returns: A const_reverse_iterator.

Note that dereferencing the iterator will yield a const T* rather than a reference.

◆ do_cast()

template<class T , class BASE >

static const T* DataVector< T, BASE >::do_cast ( const typename PtrVector::value_type p )

static

Helper to shorten calls to DataModel_detail::DVLCast.

Parameters

p	The value to convert.

Returns: The value as a const T*.

The conversion will be done with static_cast if possible, with dynamic_cast otherwise.

◆ do_cast_nc()

template<class T , class BASE >

static T* DataVector< T, BASE >::do_cast_nc ( typename PtrVector::value_type p )

static

Helper to shorten calls to DataModel_detail::DVLCast.

Parameters

p	The value to convert.

Returns: The value as a T*.

The conversion will be done with static_cast if possible, with dynamic_cast otherwise.

◆ dv_typeid()

template<class T , class BASE >

virtual const std::type_info& DataVector< T, BASE >::dv_typeid ( ) const

privatevirtual

Find the most-derived DataVector class in the hierarchy.

Returns: The type_info for the class for which this method gets run.

This is used to generate a nice error message when the most-derived check for insertions fails. Every DataVector defines this virtual method, so when it's called, the one corresponding to the most-derived DataVector gets run.

◆ dvlinfo()

template<class T , class BASE >

static const DataModel_detail::DVLInfoBase& DataVector< T, BASE >::dvlinfo ( )

static

Return the DV/DL info struct for this class.

This can be used to make sure that it's instantiated.

◆ dvlinfo_v()

template<class T , class BASE >

virtual const DataModel_detail::DVLInfoBase& DataVector< T, BASE >::dvlinfo_v ( ) const

virtual

Return the DV/DL info struct for this class.

This can be used to make sure that it's instantiated.

◆ emplace()

template<class T , class BASE >

iterator DataVector< T, BASE >::emplace	(	iterator	position,
		value_type	pElem
	)

Add a new element to the collection.

Parameters

position	Iterator before which the element will be added.
pElem	The element to add to the collection.

Returns: An iterator that points to the inserted data.

The container's ownership policy will determine if it takes ownership of the new element.

Note: this method may only be called using the most derived DataVector in the hierarchy.

For DataVector, this is just the same as insert. It's included just for interface compatibility with std::vector.

◆ emplace_back()

template<class T , class BASE >

value_type DataVector< T, BASE >::emplace_back ( value_type pElem )

Add an element to the end of the collection.

Parameters

pElem The element to add to the collection.

The container's ownership policy will determine if it takes ownership of the new element.

Note: this method may only be called using the most derived DataVector in the hierarchy.

For DataVector, this is like the same as push_back, and it returns the pushed element. It's included just for interface compatibility with std::vector.

◆ empty()

template<class T , class BASE >

bool DataVector< T, BASE >::empty ( ) const

noexcept

Returns true if the collection is empty.

◆ end() [1/2]

template<class T , class BASE >

const_iterator DataVector< T, BASE >::end ( ) const

noexcept

Return a const_iterator pointing past the end of the collection.

Returns: A const_iterator.

Note that dereferencing the iterator will yield a const T* rather than a reference.

◆ end() [2/2]

template<class T , class BASE >

iterator DataVector< T, BASE >::end ( )

noexcept

Return an iterator pointing past the end of the collection.

Returns: An iterator.

Note that dereferencing the iterator will yield a proxy rather than a reference; the proxy will handle deleting an owned element if it's assigned to.

◆ erase() [1/2]

template<class T , class BASE >

iterator DataVector< T, BASE >::erase	(	iterator	first,
		iterator	last
	)

Remove a range of elements.

Parameters

first	Iterator pointing to the first element to be removed.
last	Iterator pointing one past the last element to be removed.

Returns: An iterator pointing to the element pointed to by last prior to erasing (or end()).

If the container owns its elements, then the removed elements will be deleted. Any duplicates will be removed in this process, but don't rely on this.

◆ erase() [2/2]

template<class T , class BASE >

iterator DataVector< T, BASE >::erase ( iterator position )

Remove element at a given position.

Parameters

position Iterator pointing to the element to be removed.

Returns: An iterator pointing to the next element (or end()).

If the container owns its elements, then the pointed-to element will be deleted.

◆ front() [1/2]

template<class T , class BASE >

ElementProxy DataVector< T, BASE >::front ( )

Access the first element in the collection as an lvalue.

Returns: Proxy to the first element in the collection.

No checking is done to ensure that the container is not empty. Note that we return a proxy object rather than a reference; the proxy will handle deleting an owned element if it's assigned to.

◆ front() [2/2]

template<class T , class BASE >

const T* DataVector< T, BASE >::front ( ) const

Access the first element in the collection as an rvalue.

Returns: The first element in the collection.

No checking is done to ensure that the container is not empty. Note that we return a const T* rather than a reference.

◆ get()

template<class T , class BASE >

const T* DataVector< T, BASE >::get ( size_type n ) const

Access an element, as an rvalue.

Parameters

n	Array index to access.

Returns: The element at n.

This is a synonym for operator[] const, to be used when calling from root (where we can't readily call just the const version of a method).

◆ insert() [1/5]

template<class T , class BASE >

template<class InputIterator , DataVector_detail::enable_if_ptr_itr< InputIterator, T > = true>

void DataVector< T, BASE >::insert	(	iterator	position,
		InputIterator	first,
		InputIterator	last
	)

Add a group of new elements to the collection.

Parameters

position	Iterator before which the element will be added.
first	The start of the range to put in the container.
last	The end of the range to put in the container.

The container's ownership policy will determine if it takes ownership of the new element.

Note: this method may only be called using the most derived DataVector in the hierarchy.

This overload is for the case where the iterator value type is convertible to T*.

◆ insert() [2/5]

template<class T , class BASE >

template<class InputIterator , DataVector_detail::enable_if_up_itr< InputIterator, T > = true>

void DataVector< T, BASE >::insert	(	iterator	position,
		InputIterator	first,
		InputIterator	last
	)

Add a group of new elements to the collection.

Parameters

position	Iterator before which the element will be added.
first	The start of the range to put in the container.
last	The end of the range to put in the container.

The container's ownership policy will determine if it takes ownership of the new element.

Note: this method may only be called using the most derived DataVector in the hierarchy.

This overload is for the case where the iterator value type is convertible to unique_ptr<T>.

◆ insert() [3/5]

template<class T , class BASE >

void DataVector< T, BASE >::insert	(	iterator	position,
		std::initializer_list< value_type >	l
	)

Add a group of new elements to the collection.

Parameters

position	Iterator before which the element will be added.
l	An initializer list.

The container's ownership policy will determine if it takes ownership of the new element.

Note: this method may only be called using the most derived DataVector in the hierarchy.

◆ insert() [4/5]

template<class T , class BASE >

iterator DataVector< T, BASE >::insert	(	iterator	position,
		std::unique_ptr< base_value_type >	pElem
	)

Add a new element to the collection.

Parameters

position	Iterator before which the element will be added.
pElem	The element to add to the collection.

Returns: An iterator that points to the inserted data.

The container must be an owning container.

Note: this method may only be called using the most derived DataVector in the hierarchy.

◆ insert() [5/5]

template<class T , class BASE >

iterator DataVector< T, BASE >::insert	(	iterator	position,
		value_type	pElem
	)

Add a new element to the collection.

Parameters

position	Iterator before which the element will be added.
pElem	The element to add to the collection.

Returns: An iterator that points to the inserted data.

The container's ownership policy will determine if it takes ownership of the new element.

Note: this method may only be called using the most derived DataVector in the hierarchy.

◆ insertMove()

template<class T , class BASE >

void DataVector< T, BASE >::insertMove	(	iterator	position,
		DataVector< T, BASE > &	other
	)

Insert the contents of another DataVector, with auxiliary data copied via move semantics.

Parameters

position	Iterator before which the new elements will be added.
other	The vector to add.

The ownership mode of this vector must be the same as other; otherwise, an exception will be thrown.

If both vectors are view vectors, then this is the same as insert (position, other.begin(), other.end()) .

Otherwise, the elements from other will be inserted into this vector. This vector will take ownership of the elements, and the ownership mode of other will be changed to VIEW_ELEMENTS. Auxiliary data for these elements will be transferred, using move semantics if possible. (Thus, the auxiliary store for other may be modified and must not be locked.) Finally, the auxiliary store pointer for other will be cleared (but the store itself will not be deleted since it's not owned by the vector).

Note: this method may only be called using the most derived DataVector in the hierarchy.

◆ iter_swap()

template<class T , class BASE >

static void DataVector< T, BASE >::iter_swap	(	iterator	a,
		iterator	b
	)

static

Swap the referents of two DataVector iterators.

Parameters

a	The first iterator for the swap.
b	The second iterator for the swap.

◆ max_size()

template<class T , class BASE >

size_type DataVector< T, BASE >::max_size ( ) const

noexcept

Returns the size() of the largest possible collection.

◆ operator=() [1/3]

template<class T , class BASE >

DataVector& DataVector< T, BASE >::operator= ( const DataVector< T, BASE > & rhs )

Assignment operator.

Parameters

rhs	The DataVector from which to assign.

Returns: This object.

This is a ‘shallow’ copy; after the completion of this, the DataVector will not own its elements. Any elements it owned prior to this call will be released.

Note: this method may only be called using the most derived DataVector in the hierarchy.

◆ operator=() [2/3]

template<class T , class BASE >

DataVector& DataVector< T, BASE >::operator= ( DataVector< T, BASE > && rhs )

noexcept

Move assignment.

Parameters

rhs	The container from which to move.

Any auxiliary data will be moved along with the container contents.

◆ operator=() [3/3]

template<class T , class BASE >

DataVector& DataVector< T, BASE >::operator= ( std::initializer_list< value_type > l )

Assignment operator, from an initializer list.

Parameters

l	An initializer list.

Returns: This object.

This is equivalent to assign. Any existing owned elements will be released. The DataVector's ownership policy determines whether it will take ownership of the new elements.

◆ operator[]() [1/2]

template<class T , class BASE >

ElementProxy DataVector< T, BASE >::operator[] ( size_type n )

Access an element, as an lvalue.

Parameters

n	Array index to access.

Returns: Proxy to the element at n.

No bounds checking is done. Note that we return a proxy object rather than a reference; the proxy will handle deleting an owned element if it's assigned to.

◆ operator[]() [2/2]

template<class T , class BASE >

const T* DataVector< T, BASE >::operator[] ( size_type n ) const

Access an element, as an rvalue.

Parameters

n	Array index to access.

Returns: The element at n.

No bounds checking is done. Note that we return a const T* rather than a reference.

◆ ownPolicy()

template<class T , class BASE >

SG::OwnershipPolicy DataVector< T, BASE >::ownPolicy ( ) const

Return the ownership policy setting for this container.

◆ pop_back() [1/2]

template<class T , class BASE >

void DataVector< T, BASE >::pop_back ( )

Remove the last element from the collection.

If the container owns its elements, then the removed element will be deleted.

◆ pop_back() [2/2]

template<class T , class BASE >

void DataVector< T, BASE >::pop_back ( )

◆ push_back() [1/2]

template<class T , class BASE >

value_type DataVector< T, BASE >::push_back ( std::unique_ptr< base_value_type > pElem )

Add an element to the end of the collection.

Parameters

pElem The element to add to the collection.

The container must be an owning container.

Note: this method may only be called using the most derived DataVector in the hierarchy.

Returns the pushed pointer.

◆ push_back() [2/2]

template<class T , class BASE >

value_type DataVector< T, BASE >::push_back ( value_type pElem )

Add an element to the end of the collection.

Parameters

pElem The element to add to the collection.

The container's ownership policy will determine if it takes ownership of the new element.

Note: this method may only be called using the most derived DataVector in the hierarchy.

Returns the pushed pointer.

◆ rbegin() [1/2]

template<class T , class BASE >

const_reverse_iterator DataVector< T, BASE >::rbegin ( ) const

noexcept

Return a const_reverse_iterator pointing past the end of the collection.

Returns: A const_reverse_iterator.

Note that dereferencing the iterator will yield a const T* rather than a reference.

◆ rbegin() [2/2]

template<class T , class BASE >

reverse_iterator DataVector< T, BASE >::rbegin ( )

noexcept

Return a reverse_iterator pointing past the end of the collection.

Returns: A reverse_iterator.

Note that dereferencing the iterator will yield a proxy rather than a reference; the proxy will handle deleting an owned element if it's assigned to.

◆ rend() [1/2]

template<class T , class BASE >

const_reverse_iterator DataVector< T, BASE >::rend ( ) const

noexcept

Return a const_reverse_iterator pointing at the beginning of the collection.

Returns: A const_reverse_iterator.

Note that dereferencing the iterator will yield a const T* rather than a reference.

◆ rend() [2/2]

template<class T , class BASE >

reverse_iterator DataVector< T, BASE >::rend ( )

noexcept

Return a reverse_iterator pointing at the beginning of the collection.

Returns: A reverse_iterator.

Note that dereferencing the iterator will yield a proxy rather than a reference; the proxy will handle deleting an owned element if it's assigned to.

◆ reserve()

template<class T , class BASE >

void DataVector< T, BASE >::reserve ( size_type n )

Attempt to preallocate enough memory for a specified number of elements.

Parameters

n	Number of elements required.

◆ resize() [1/2]

template<class T , class BASE >

void DataVector< T, BASE >::resize ( size_type sz )

Resizes the collection to the specified number of elements.

Parameters

sz	The new size of the collection.

Note that this function differs from the standard in that it does not allow specifying the value of any inserted elements. They will always be 0.

If the container is shrunk, elements will be deleted as with erase().

◆ resize() [2/2]

template<class T , class BASE >

void DataVector< T, BASE >::resize ( size_type sz )

◆ resortAux()

template<class T , class BASE >

void DataVector< T, BASE >::resortAux	(	iterator	beg,
		iterator	end
	)

Reset indices / reorder aux data after elements have been permuted.

Parameters

beg	Start of the range of elements to process.
end	End of the range of elements to process.

Call this after some operation that has permuted the elements in the container (such as sort). The index information in the elements will be used to permute all auxiliary data in the same way. Finally, all the indices will be reset in the correct order.

◆ setMostDerived()

template<class T , class BASE >

virtual void DataVector< T, BASE >::setMostDerived ( )

protectedvirtual

Set m_isMostDerived for this instance and clear it for all bases.

Called from testInsert if the test fails. The flag may not have been set if this container was made via copy construction, so set it appropriately now so we can test again.

◆ shift()

template<class T , class BASE >

void DataVector< T, BASE >::shift	(	size_t	pos,
		ptrdiff_t	offs
	)

private

Shift the auxiliary elements of the container.

Parameters

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

The elements in the container should have already been shifted; this operation will then adjust the element indices and also shift the elements in the vectors for all aux data items. 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).

◆ shrink_to_fit()

template<class T , class BASE >

void DataVector< T, BASE >::shrink_to_fit ( )

◆ size()

template<class T , class BASE >

size_type DataVector< T, BASE >::size ( ) const

noexcept

Returns the number of elements in the collection.

Could in principle be inherited from the base class, but redeclared in the derived class to avoid root6 bugs.

◆ sort() [1/2]

template<class T , class BASE >

void DataVector< T, BASE >::sort ( )

Sort the container.

This just sorts by pointer value, so it's probably not very useful.

◆ sort() [2/2]

template<class T , class BASE >

template<class COMPARE >

void DataVector< T, BASE >::sort ( COMPARE comp )

Sort the container with a user-specified comparison operator.

Parameters

comp	Functional to compare two values.

◆ stdcont()

template<class T , class BASE >

const PtrVector & DataVector< T, BASE >::stdcont ( ) const

Return the underlying std::vector of the container.

Returns: Reference to the std::vector actually holding the collection.

Note that DataVector<T>::stdcont does not necessarily return a std::vector<T*> if DataVector inheritance is being used.

◆ swap()

template<class T , class BASE >

void DataVector< T, BASE >::swap ( DataVector< T, BASE > & rhs )

Swap this collection with another.

Parameters

rhs	The collection with which to swap.

Ownership is swapped along with the collection content.

Note: this method may only be called using the most-derived DataVector in the hierarchy. The rhs must also be referenced using the most-derived DataVector.

◆ swapElement() [1/4]

template<class T , class BASE >

void DataVector< T, BASE >::swapElement	(	iterator	pos,
		std::unique_ptr< base_value_type >	newElem,
		std::unique_ptr< base_value_type > &	oldElem
	)

Swap one element out of the container.

Parameters

pos	The element in the container to swap.
newElem	New element to put in the container. May be 0.
oldElem	Reference to receive the element removed from the container.

Reference oldElem is initialized with element pos of the collection (no bounds checking). Then element index is set to newElem.

The collection must own its elements to use its interface. The collection will take ownership of newElem and will return ownership of oldElem.

Note: this method may only be called using the most derived DataList in the hierarchy.

◆ swapElement() [2/4]

template<class T , class BASE >

void DataVector< T, BASE >::swapElement	(	iterator	pos,
		value_type	newElem,
		reference	oldElem
	)

Swap one element out of the container.

Parameters

pos	The element in the container to swap.
newElem	New element to put in the container. May be 0.
oldElem	Reference to receive the element removed from the container.

Reference oldElem is initialized with element pos of the collection (no bounds checking). Then element index is set to newElem. If the collection owns its elements, then it will take ownership of newElem and release (without deleting) the element returned through oldElem.

Note: this method may only be called using the most derived DataList in the hierarchy.

◆ swapElement() [3/4]

template<class T , class BASE >

void DataVector< T, BASE >::swapElement	(	size_type	index,
		std::unique_ptr< base_value_type >	newElem,
		std::unique_ptr< base_value_type > &	oldElem
	)

Swap one element out of the container.

Parameters

index	Index of the element in the container to swap.
newElem	New element to put in the container. May be 0.
oldElem	Reference to receive the element removed from the container.

Reference oldElem is initialized with element index of the collection (no bounds checking). Then element index is set to newElem.

The collection must own its elements to use its interface. The collection will take ownership of newElem and will return ownership of oldElem.

Note: this method may only be called using the most derived DataVector in the hierarchy.

◆ swapElement() [4/4]

template<class T , class BASE >

void DataVector< T, BASE >::swapElement	(	size_type	index,
		value_type	newElem,
		reference	oldElem
	)

Swap one element out of the container.

Parameters

index	Index of the element in the container to swap.
newElem	New element to put in the container. May be 0.
oldElem	Reference to receive the element removed from the container.

Reference oldElem is initialized with element index of the collection (no bounds checking). Then element index is set to newElem. If the collection owns its elements, then it will take ownership of newElem and release (without deleting) the element returned through oldElem.

Note: this method may only be called using the most derived DataVector in the hierarchy.

◆ testInsert()

template<class T , class BASE >

void DataVector< T, BASE >::testInsert ( const char * op )

Test if we can insert; raise an exception if not.

Parameters

op	Description of the attempted operation.

In order to maintain type-safety, we can only allow insertions using the most-derived instance of DataVector. This checks this by testing the m_isMostDerived, which is set by the constructors to true only for the most-derived instance. If the test fails, we call to potentially out-of-line code to continue.

◆ testInsertOol()

template<class T , class BASE >

void DataVector< T, BASE >::testInsertOol ( const char * op )

Test if we can insert; raise an exception if not.

Parameters

op	Description of the attempted operation.

This continues the test of testInsert. There is one case where m_isMostDerived may not be set correctly. If this container was made via copy construction, then all the m_isMostDerived flags will be false. So we call setMostDerived to set the flags correctly and test again. If the test fails again, then we raise an exception.

Friends And Related Function Documentation

◆ ConstDataVector

template<class T , class BASE >

template<class DV >

friend class ConstDataVector

friend

Definition at line 1903 of file DataVector.h.

◆ DataModel_detail::ElementProxy< DataVector >

template<class T , class BASE >

friend class DataModel_detail::ElementProxy< DataVector >

friend

Definition at line 1897 of file DataVector.h.

◆ DataVectorWithAlloc

template<class T , class BASE >

template<class DV , class ALLOC >

friend class DataVectorWithAlloc

friend

Definition at line 1905 of file DataVector.h.

◆ test2_assignelement1

template<class T , class BASE >

void test2_assignelement1 ( )

friend

◆ test2_assignelement1a

template<class T , class BASE >

void test2_assignelement1a ( )

friend

◆ test2_assignelement2

template<class T , class BASE >

void test2_assignelement2 ( )

friend

Member Data Documentation

◆ has_virtual

template<class T , class BASE >

const bool DataVector< T, BASE >::has_virtual = BASE::has_virtual

static

This is true for any DataVector class if we need to use virtual derivation to get to the base DataVector class.

Definition at line 801 of file DataVector.h.

◆ m_deleter

template<class T , class BASE >

ROOT_SELECTION_NS::MemberAttributes< kTransient > DataVector< T, BASE >::m_deleter

Definition at line 3436 of file DataVector.h.

◆ m_isMostDerived [1/2]

template<class T , class BASE >

SG::IsMostDerivedFlag DataVector< T, BASE >::m_isMostDerived

private

This flag is true if this DV instance is the most-derived one.

We set this to true in the top-level constructor; the constructor then calls clearMostDerived on the base classes.

Definition at line 2038 of file DataVector.h.

◆ m_isMostDerived [2/2]

template<class T , class BASE >

ROOT_SELECTION_NS::MemberAttributes< kTransient > DataVector< T, BASE >::m_isMostDerived

Automatically generate dictionary for contained vector.

Declare the automatically created variable transient

Definition at line 3435 of file DataVector.h.

◆ m_ownPolicy

template<class T , class BASE >

ROOT_SELECTION_NS::MemberAttributes< kTransient > DataVector< T, BASE >::m_ownPolicy

We do not want to save this.

The P->T converter should decide the ownership mode.

Definition at line 3440 of file DataVector.h.

◆ must_own

template<class T , class BASE >

constexpr bool DataVector< T, BASE >::must_own = BASE::must_own

staticconstexpr

If true, then this type must own its contents.

Definition at line 859 of file DataVector.h.

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

DataVector.h

Public Types

Public Attributes

Static Public Attributes

Constructors, destructors, assignment.

Swap and sort.

Non-standard operations.

Internal operations.

Detailed Description

template<class T, class BASE> class DataVector< T, BASE >

Member Typedef Documentation

◆ allocator_type

◆ base_data_vector

◆ base_value_type

◆ BaseContainer

◆ const_iterator

◆ const_pointer

◆ const_reference

◆ const_reverse_iterator

◆ const_value_type

◆ DataVector_BASE

◆ Deleter

◆ difference_type

◆ DVL_BASE

◆ ElementProxy

◆ iterator

◆ pointer

◆ PtrVector

◆ reference

◆ reverse_iterator

◆ self [1/2]

◆ self [2/2]

◆ size_type

◆ unique_type

◆ value_type

Constructor & Destructor Documentation

◆ DataVector() [1/6]

◆ DataVector() [2/6]

◆ DataVector() [3/6]

◆ DataVector() [4/6]

◆ DataVector() [5/6]

◆ DataVector() [6/6]

Member Function Documentation

◆ assign() [1/2]

◆ assign() [2/2]

◆ assignBaseElement()

◆ assignElement() [1/2]

◆ assignElement() [2/2]

◆ at() [1/2]

◆ at() [2/2]

◆ auxbase()

◆ back() [1/2]

◆ back() [2/2]

◆ baseOffset()

◆ baseOffset1()

◆ begin() [1/2]

◆ begin() [2/2]

◆ capacity()

◆ cbegin()

◆ cend()

◆ clear() [1/6]

◆ clear() [2/6]

◆ clear() [3/6]

◆ clear() [4/6]

◆ clear() [5/6]

◆ clear() [6/6]

◆ clearMostDerived()

◆ crbegin()

◆ crend()

◆ do_cast()

◆ do_cast_nc()

◆ dv_typeid()

◆ dvlinfo()

◆ dvlinfo_v()

◆ emplace()

◆ emplace_back()

◆ empty()

◆ end() [1/2]

◆ end() [2/2]

◆ erase() [1/2]

◆ erase() [2/2]

template<class T, class BASE>
class DataVector< T, BASE >