DataVector< T, DataModel_detail::NoBase > Class Template Reference

Base specialization for DataVector<T>. More...

#include <DataVector.h>

Inheritance diagram for DataVector< T, DataModel_detail::NoBase >:

Public Types
typedef DataModel_detail::NoBase	DataVector_BASE
typedef DataModel_detail::NoBase	DVL_BASE
typedef boost::true_type	isSequence
	Mark as a sequence, for DataLink / ElementLink.
typedef std::vector< T * >	PtrVector
typedef std::vector< T * >	BaseContainer
typedef T *&	reference
typedef T *const &	const_reference
typedef PtrVector::size_type	size_type
typedef PtrVector::difference_type	difference_type
typedef T *	value_type
typedef PtrVector::allocator_type	allocator_type
typedef T **	pointer
typedef T const	const_pointer
typedef const T *	const_value_type
typedef T	base_value_type
typedef DataModel_detail::ElementProxy < DataVector >	ElementProxy
typedef PtrVector::const_iterator	const_iterator
	Standard `const_iterator`.
typedef DataModel_detail::iterator < DataVector >	iterator
typedef std::reverse_iterator < const_iterator >	const_reverse_iterator
	Standard `const_reverse_iterator`.
typedef std::reverse_iterator < iterator >	reverse_iterator
Public Member Functions
Constructors, destructors, assignment.

	DataVector (SG::OwnershipPolicy ownPolicy=SG::OWN_ELEMENTS, SG::IndexTrackingPolicy trackIndices=SG::DEFAULT_TRACK_INDICES)
	Default constructor.
	DataVector (size_type n, SG::OwnershipPolicy ownPolicy=SG::OWN_ELEMENTS, SG::IndexTrackingPolicy trackIndices=SG::DEFAULT_TRACK_INDICES)
	Sized constructor.
	DataVector (const DataVector &rhs)
	Copy constructor.
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.
DataVector &	operator= (const DataVector &rhs)
	Assignment operator.
template<class InputIterator >
void	assign (InputIterator first, InputIterator last)
	Assign from iterators.
virtual	~DataVector ()
	Destructor.
Size and capacity.

size_type	size () const
	Returns the number of elements in the collection.
virtual size_type	size_v () const
	Returns the number of elements in the collection.
size_type	max_size () const
	Returns the `size()` of the largest possible collection.
void	resize (size_type sz)
	Resizes the collection to the specified number of elements.
size_type	capacity () const
	Returns the total number of elements that the collection can hold before needing to allocate more memory.
virtual size_type	capacity_v () const
	Returns the total number of elements that the collection can hold before needing to allocate more memory.
bool	empty () const
	Returns `true` if the collection is empty.
void	reserve (size_type n)
	Attempt to preallocate enough memory for a specified number of elements.
Element access.

const T *	operator[] (size_type n) const
	Access an element, as an rvalue.
const T *	get (size_type n) const
	Access an element, as an rvalue.
ElementProxy	operator[] (size_type n)
	Access an element, as an lvalue.
const T *	at (size_type n) const
	Access an element, as an rvalue.
ElementProxy	at (size_type n)
	Access an element, as an lvalue.
const T *	front () const
	Access the first element in the collection as an rvalue.
const T *	back () const
	Access the last element in the collection as an rvalue.
ElementProxy	front ()
	Access the first element in the collection as an lvalue.
ElementProxy	back ()
	Access the last element in the collection as an lvalue.
Iterator creation.

const_iterator	begin () const
	Return a `const_iterator` pointing at the beginning of the collection.
const_iterator	end () const
	Return a `const_iterator` pointing past the end of the collection.
iterator	begin ()
	Return an `iterator` pointing at the beginning of the collection.
iterator	end ()
	Return an `iterator` pointing past the end of the collection.
const_reverse_iterator	rbegin () const
	Return a `const_reverse_iterator` pointing past the end of the collection.
const_reverse_iterator	rend () const
	Return a `const_reverse_iterator` pointing at the beginning of the collection.
reverse_iterator	rbegin ()
	Return a `reverse_iterator` pointing past the end of the collection.
reverse_iterator	rend ()
	Return a `reverse_iterator` pointing at the beginning of the collection.
const_iterator	cbegin () const
	Return a `const_iterator` pointing at the beginning of the collection.
const_iterator	cend () const
	Return a `const_iterator` pointing past the end of the collection.
const_reverse_iterator	crbegin () const
	Return a `const_reverse_iterator` pointing past the end of the collection.
const_reverse_iterator	crend () const
	Return a `const_reverse_iterator` pointing at the beginning of the collection.
Insertion operations.

void	push_back (value_type pElem)
	Add an element to the end of the collection.
void	emplace_back (value_type pElem)
	Add an element to the end of the collection.
iterator	insert (iterator position, value_type pElem)
	Add a new element to the collection.
iterator	emplace (iterator position, value_type pElem)
	Add a new element to the collection.
template<class InputIterator >
void	insert (iterator position, InputIterator first, InputIterator last)
	Add a group of new elements to the collection.
Erasure operations.

iterator	erase (iterator position)
	Remove element at a given position.
iterator	erase (iterator first, iterator last)
	Remove a range of elements.
void	pop_back ()
	Remove the last element from the collection.
void	clear ()
	Erase all the elements in the collection.
Static Public Attributes
static const bool	has_virtual = false
Internal operations.

class	DataModel_detail::ElementProxy< DataVector >
class	ConstDataVector< DataVector >
void	test2_assignelement1 ()
void	test2_assignelement2 ()
SG::OwnershipPolicy	m_ownPolicy
PtrVector	m_pCont
	This actually holds the elements.
void	resortAux (iterator beg, iterator end)
	Reset indices / reorder aux data after elements have been permuted.
void	testInsert (const char *op)
	Test if we can insert; raise an exception if not.
void	testInsertOol (const char *op)
	Test if we can insert; raise an exception if not.
static int	baseOffset1 (const char *p, const DataVector &dv, const std::type_info &ti)
	Helper for `baseOffset`.
static const T *	do_cast (const typename PtrVector::value_type p)
	Helper to shorten calls to `DataModel_detail::DVLCast`.
PtrVector::iterator	erase_base (typename PtrVector::iterator position)
	Helper for `erase()`. Remove element at a given position.
PtrVector::iterator	erase_base (typename PtrVector::iterator first, typename PtrVector::iterator last)
	Helper for `erase()`. Remove a range of elements.
void	clearMostDerived ()
	Clear `m_isMostDerived` for this instance and for all bases.
virtual void	setMostDerived ()
	Set `m_isMostDerived` for this instance and clear it for all bases.
Swap and sort.

void	swap (DataVector &rhs)
	Swap this collection with another.
void	sort ()
	Sort the container.
template<class COMPARE >
void	sort (COMPARE comp)
	Sort the container with a user-specified comparison operator.
static void	iter_swap (iterator a, iterator b)
	Swap the referents of two `DataVector` iterators.
Non-standard operations.

void	swapElement (size_type index, value_type newElem, reference oldElem)
	Swap one element out of the container.
void	swapElement (iterator pos, value_type newElem, reference oldElem)
	Swap one element out of the container.
const PtrVector &	stdcont () const
	Return the underlying `std::vector` of the container.
SG::OwnershipPolicy	ownPolicy () const
	Return the ownership policy setting for this container.
void	clear (SG::OwnershipPolicy ownPolicy)
	Erase all the elements in the collection, and reset the ownership mode.
void	clear (SG::OwnershipPolicy ownPolicy, SG::IndexTrackingPolicy trackIndices)
	Erase all the elements in the collection, and reset the ownership mode.
virtual const DataModel_detail::DVLInfoBase &	dvlinfo_v () const
	Return the DV/DL info struct for this class.
const SG::AuxVectorBase &	auxbase () const
	Convert to `AuxVectorBase`.
static const DataModel_detail::DVLInfoBase &	dvlinfo ()
	Return the DV/DL info struct for this class.
static int	baseOffset (const std::type_info &ti)
	Return the offset of a base `DataVector` class.

Detailed Description

template<class T>
class DataVector< T, DataModel_detail::NoBase >

Base specialization for DataVector<T>.

This is used for the case where T does not derive from other classes. This is the class which actually holds the vector of pointers.

See the file comments for full details.

Member Typedef Documentation

template<class T >

typedef T DataVector< T, DataModel_detail::NoBase >::base_value_type

The T value used as the template parameter. Note that this is different from value_type (that's T*).

template<class T >

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

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

template<class T >

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

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

template<class T >

typedef std::vector<T*> DataVector< T, DataModel_detail::NoBase >::PtrVector

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

template<class T >

typedef std::reverse_iterator<iterator> DataVector< T, DataModel_detail::NoBase >::reverse_iterator

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

Constructor & Destructor Documentation

template<class T >

DataVector< T, DataModel_detail::NoBase >::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.

template<class T >

DataVector< T, DataModel_detail::NoBase >::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.

template<class T >

DataVector< T, DataModel_detail::NoBase >::DataVector ( const DataVector< T, DataModel_detail::NoBase > & rhs )

Copy constructor.

Parameters:

rhs

The container from which to copy.

This is a `shallow' copy; the new container will not own its elements.

template<class T >

template<class InputIterator >

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

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 DataVector will own its elements (and take ownership of the pointers passed to this constructor). To avoid this, pass SG::VIEW_ELEMENTS for ownPolicy.

template<class T >

virtual DataVector< T, DataModel_detail::NoBase >::~DataVector ( ) [virtual]

Destructor.

If this container owns its elements, the contained elements will be deleted as well. Before doing this, the destructor will scan for duplicate pointers (takes $n \log n$ time); duplicates are only destroyed once. Duplicates should, however, be considered an error; don't rely on this behavior.

Member Function Documentation

template<class T >

template<class InputIterator >

void DataVector< T, DataModel_detail::NoBase >::assign	(	InputIterator	first,
		InputIterator	last
	)			`[inline]`

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.

template<class T >

ElementProxy DataVector< T, DataModel_detail::NoBase >::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.

template<class T >

const T* DataVector< T, DataModel_detail::NoBase >::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.

template<class T >

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

Convert to AuxVectorBase.

Needed to get AuxVectorBase from a ConstDataVector. Present in DataVector as well for consistency.

template<class T >

ElementProxy DataVector< T, DataModel_detail::NoBase >::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.

template<class T >

const T* DataVector< T, DataModel_detail::NoBase >::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.

template<class T >

static int DataVector< T, DataModel_detail::NoBase >::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.

template<class T >

static int DataVector< T, DataModel_detail::NoBase >::baseOffset1	(	const char *	p,
		const DataVector< T, DataModel_detail::NoBase > &	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.

template<class T >

iterator DataVector< T, DataModel_detail::NoBase >::begin ( )

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.

template<class T >

const_iterator DataVector< T, DataModel_detail::NoBase >::begin ( ) const

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.

template<class T >

virtual size_type DataVector< T, DataModel_detail::NoBase >::capacity_v ( ) const [virtual]

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

This version is virtual, to be callable from the AuxData base class.

Implements SG::AuxVectorData.

template<class T >

const_iterator DataVector< T, DataModel_detail::NoBase >::cbegin ( ) const

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.

template<class T >

const_iterator DataVector< T, DataModel_detail::NoBase >::cend ( ) const

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.

template<class T >

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

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

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.

template<class T >

void DataVector< T, DataModel_detail::NoBase >::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.

template<class T >

void DataVector< T, DataModel_detail::NoBase >::clear ( )

Erase all the elements in the collection.

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.

template<class T >

void DataVector< T, DataModel_detail::NoBase >::clearMostDerived ( ) [protected]

Clear m_isMostDerived for this instance and for all bases.

Called from the constructor after setting m_isMostDerived.

template<class T >

const_reverse_iterator DataVector< T, DataModel_detail::NoBase >::crbegin ( ) const

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.

template<class T >

const_reverse_iterator DataVector< T, DataModel_detail::NoBase >::crend ( ) const

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.

template<class T >

static const T* DataVector< T, DataModel_detail::NoBase >::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*.

This is a no-op for the base class.

template<class T >

static const DataModel_detail::DVLInfoBase& DataVector< T, DataModel_detail::NoBase >::dvlinfo ( ) [static]

Return the DV/DL info struct for this class.

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

template<class T >

virtual const DataModel_detail::DVLInfoBase& DataVector< T, DataModel_detail::NoBase >::dvlinfo_v ( ) const [virtual]

Return the DV/DL info struct for this class.

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

template<class T >

iterator DataVector< T, DataModel_detail::NoBase >::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 `stdvector`.

template<class T >

void DataVector< T, DataModel_detail::NoBase >::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 just the same as push_back. It's included just for interface compatibility with `stdvector`.

template<class T >

iterator DataVector< T, DataModel_detail::NoBase >::end ( )

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.

template<class T >

const_iterator DataVector< T, DataModel_detail::NoBase >::end ( ) const

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.

template<class T >

iterator DataVector< T, DataModel_detail::NoBase >::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.

template<class T >

iterator DataVector< T, DataModel_detail::NoBase >::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.

template<class T >

PtrVector::iterator DataVector< T, DataModel_detail::NoBase >::erase_base	(	typename PtrVector::iterator	first,
		typename PtrVector::iterator	last
	)			`[protected]`

Helper for erase(). 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()).

This function factors out common code between erase() in the base and derived DataVector classes. It deals with the std::vector iterators directly.

template<class T >

PtrVector::iterator DataVector< T, DataModel_detail::NoBase >::erase_base ( typename PtrVector::iterator position ) [protected]

Helper for erase(). 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()).

This function factors out common code between erase() in the base and derived DataVector classes. It deals with the std::vector iterators directly.

template<class T >

ElementProxy DataVector< T, DataModel_detail::NoBase >::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.

template<class T >

const T* DataVector< T, DataModel_detail::NoBase >::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.

template<class T >

const T* DataVector< T, DataModel_detail::NoBase >::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).

template<class T >

template<class InputIterator >

void DataVector< T, DataModel_detail::NoBase >::insert	(	iterator	position,
		InputIterator	first,
		InputIterator	last
	)			`[inline]`

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.

template<class T >

iterator DataVector< T, DataModel_detail::NoBase >::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.

template<class T >

static void DataVector< T, DataModel_detail::NoBase >::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/

template<class T >

DataVector& DataVector< T, DataModel_detail::NoBase >::operator= ( const DataVector< T, DataModel_detail::NoBase > & 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.

template<class T >

ElementProxy DataVector< T, DataModel_detail::NoBase >::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.

template<class T >

const T* DataVector< T, DataModel_detail::NoBase >::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.

template<class T >

void DataVector< T, DataModel_detail::NoBase >::pop_back ( )

Remove the last element from the collection.

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

template<class T >

void DataVector< T, DataModel_detail::NoBase >::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.

template<class T >

reverse_iterator DataVector< T, DataModel_detail::NoBase >::rbegin ( )

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.

template<class T >

const_reverse_iterator DataVector< T, DataModel_detail::NoBase >::rbegin ( ) const

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.

template<class T >

reverse_iterator DataVector< T, DataModel_detail::NoBase >::rend ( )

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.

template<class T >

const_reverse_iterator DataVector< T, DataModel_detail::NoBase >::rend ( ) const

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.

template<class T >

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

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

Parameters:

n

Number of elements required.

template<class T >

void DataVector< T, DataModel_detail::NoBase >::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().

template<class T >

void DataVector< T, DataModel_detail::NoBase >::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.

template<class T >

virtual void DataVector< T, DataModel_detail::NoBase >::setMostDerived ( ) [protected, virtual]

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.

template<class T >

virtual size_type DataVector< T, DataModel_detail::NoBase >::size_v ( ) const [virtual]

Returns the number of elements in the collection.

This version is virtual, to be callable from the AuxData base class.

Implements SG::AuxVectorData.

template<class T >

template<class COMPARE >

void DataVector< T, DataModel_detail::NoBase >::sort ( COMPARE comp ) [inline]

Sort the container with a user-specified comparison operator.

Parameters:

comp

Functional to compare two values.

template<class T >

void DataVector< T, DataModel_detail::NoBase >::sort ( )

Sort the container.

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

template<class T >

const PtrVector& DataVector< T, DataModel_detail::NoBase >::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.

template<class T >

void DataVector< T, DataModel_detail::NoBase >::swap ( DataVector< T, DataModel_detail::NoBase > & 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.

template<class T >

void DataVector< T, DataModel_detail::NoBase >::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 DataVector in the hierarchy.

template<class T >

void DataVector< T, DataModel_detail::NoBase >::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.

template<class T >

void DataVector< T, DataModel_detail::NoBase >::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.

template<class T >

void DataVector< T, DataModel_detail::NoBase >::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.

Member Data Documentation

template<class T >

const bool DataVector< T, DataModel_detail::NoBase >::has_virtual = false [inline, static]

This is true for any DataVector class if we need to use virtual derivation to get to the base DataVector class. Since this is the base DataVector class, set this unconditionally to false.

template<class T >

SG::OwnershipPolicy DataVector< T, DataModel_detail::NoBase >::m_ownPolicy [protected]

The ownership policy of this container --- either SG::OWNS_ELEMENTS or SG::VIEW_ELEMENTS.

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

/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.28/AthContainers/AthContainers/DataVector.h

DataVector< T, DataModel_detail::NoBase > Class Template Reference

Public Types

Public Member Functions

Static Public Attributes

Internal operations.

Swap and sort.

Non-standard operations.

Detailed Description

template<class T> class DataVector< T, DataModel_detail::NoBase >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<class T>
class DataVector< T, DataModel_detail::NoBase >