A contiguous data container expanded on write. More...

#include "LazyVector.h"

Public Types
STL vector types
using	allocator_type = typename Data_t::allocator_type

using	value_type = typename Data_t::value_type

using	size_type = typename Data_t::size_type

using	difference_type = typename Data_t::difference_type

using	reference = typename Data_t::reference

using	const_reference = typename Data_t::const_reference

using	pointer = typename Data_t::pointer

using	const_pointer = typename Data_t::const_pointer

Public Member Functions
	LazyVector ()=default

	LazyVector (allocator_type const &a)
	Constructor: like default, but using the specified allocator. More...

	LazyVector (size_type n)
	Constructor: a lazy vector with a specified maximum size. More...

	LazyVector (size_type n, value_type const &defValue)
	Constructor: a lazy vector with a specified maximum size. More...

reference	at (size_type pos)
	Returns a reference to the specified element, throws an exception if not present. More...

Container information
— END Constructors -------------------------------------------——
size_type	size () const noexcept
	Returns the size of the vector. More...

bool	empty () const noexcept
	Returns whether the vector is empty. More...

size_type	data_size () const noexcept
	Returns the size of data actually stored. More...

bool	has_index (size_type pos) const noexcept
	Returns whether the specified position is within the vector. More...

bool	data_empty () const noexcept
	Returns whether no data is actually stored. More...

value_type const &	data_defvalue () const

size_type	data_begin_index () const

size_type	data_end_index () const

bool	data_has_index (size_type pos) const
	Returns the internal storage index for the specified position. More...

const_pointer	data_address (size_type pos) const
	Returns a constant pointer to the specified element. More...

Access to data elements
There are important differences between the access methods of `LazyVector` and the ones of STL `vector`. The constant versions of the access methods differ from the corresponding STL `vector` ones in that they return a copy of the element rather than a reference to it. This happens because the element could not have current storage, and we can't create it because the method is constant. Also, the non-constant versions of the access methods always ensure storage for the accessed element. If such behaviour needs to be avoided (e.g. for performance reasons), use the methods explicitly named constant: `const_at()` and `const_get()`, explicitly constant versions of `at()` and `operator[]` respectively. To preserve the naming scheme, a method `get()` is also provided which is equivalent to the non-constant version of `operator[]`.
value_type	at (size_type pos) const
	Returns a reference to the specified element, throws an exception if not present. More...

value_type	const_at (size_type pos) const
	Returns a reference to the specified element, throws an exception if not present. More...


value_type	operator[] (size_type pos) const
	Returns a copy of the specified element. More...

value_type	const_get (size_type pos) const
	Returns a copy of the specified element. More...


reference	operator[] (size_type pos)
	Returns a reference to the specified element. More...

reference	get (size_type pos)
	Returns a reference to the specified element. More...

Container operations
void	resize (size_type newSize)
	Changes the nominal size of the container. More...

void	reserve (size_type n)
	Allocates enough memory in storage to store `n` elements. More...

void	clear ()
	Removes all stored data and sets the nominal size to 0. More...

void	shrink_to_fit ()
	Reduces memory usage to the amount needed by the elements with storage. More...

void	data_prepare (size_type startIndex, size_type endIndex)
	Prepares the vector to store elements in the specified range. More...

void	data_prepare (size_type n)
	Prepares the vector to store `n` elements from `0`. More...

void	data_init (size_type startIndex, size_type endIndex)
	Allocates the specified range and stores default values for it. More...

void	data_init (size_type n)
	Allocates and initializes `n` elements starting from index 0. More...

Private Types
using	Data_t = std::vector< T, A >
	Actual data storage type. More...

Private Member Functions
size_type	index_of (size_type pos) const
	Returns the internal storage index for the specified position. More...

void	expand (size_type pos)
	Expands the storage to include the specified position. More...

void	init (size_type pos, size_type n=1U)
	Makes the first data allocation. More...

void	expand_front (size_type pos)
	Expands the storage to include the specified position behind it. More...

void	expand_back (size_type pos)
	Expands the storage to include the specified position ahead of it. More...

void	fix_size ()
	Makes sure the nominal size is large enough to include all stored data. More...

void	data_clear ()
	Erases all stored data from the container; nominal size is not changed. More...

void	check_range (size_type pos) const
	Throws `std::out_of_range` if `pos` is not contained in the vector. More...


Data_t &	storage ()
	Returns the data storage. More...

Data_t const &	storage () const
	Returns the data storage. More...

Static Private Member Functions
static value_type const &	defaultValueType ()
	Returns the class default value (used when user does not specify any). More...

Private Attributes
Data_t	fData
	Actual data storage. More...

size_type	fNominalSize = 0U
	Alleged data size. More...

size_type	fFirstIndex = fData.max_size()
	First element currently stored. More...

value_type	fDefValue = defaultValueType()
	Default value. More...

Static Private Attributes
static value_type const	fDefaultDefaultValue {}
	Default-initialised value of type `value_type` used as default fallback. More...

Detailed Description

template<typename T, typename A = typename std::vector<T>::allocator_type>
class util::LazyVector< T, A >

A contiguous data container expanded on write.

Template Parameters

T	type of contained data
A	allocator for the data (default: STL vector's default allocator)

This container class represents a number of data elements contiguously allocated in memory. It mimics the behaviour and interface of STL vector, but the actual data allocation is lazy, that is it happens only when writing to an element is requested. The internal allocation is always contiguous, including as little data as it can accommodate elements from the first to the last index written at any point.

The interface is also a partial replica of STL vector, with the addition of members specific to this class, whose names start with data_. Among the relevant features missing from this object there is iterators.

For some internal resizing operations, a default value is used to construct the new values. This default value can be specified in some constructors, Otherwise, a value equivalent to 0 (i.e. value_type(0)) is used for arithmetic value types, and the default-constructed value is used for all other types.

Example of usage:

// start with a lazy vector of nominal size 6 elements and no actual data:
util::LazyVector<double> v(6U);
// add a value `-4.0` at the previous-to-last element `4`:
// the vector will look like: { ... [4] -4.0 ... }
// (nominal size: 6, 1 stored datum)
v[4] = -4.0;
// add a value `-2.0` at the third element:
// the vector will look like: { ... [2] -2.0, [3] def, [4] -4.0 ... }
// (nominal size still 6, 3 stored data, the default value "def" is 0.0)
v[2] = -2.0;
// we want to set element #6 to -6.0: we need to expand the vector first.
v.resize(7U); // barely enough for element #6
// the vector will look like: { ... [2] -2.0, [3] def, [4] -4.0 [5] def [6] -6.0 }
// (nominal size 7, 5 stored data, the default value "def" is 0.0)
v[6] = -6.0;

Note: Special care needs to be used when accessing a non-const LazyVector, since every access will create storage for the specified element (like in STL map operator[]). For this reason, the special methods const_at(size_type) and const_get(size_type) are provided, which never create storage.

Definition at line 78 of file LazyVector.h.

Member Typedef Documentation

template<typename T, typename A = typename std::vector<T>::allocator_type>

using util::LazyVector< T, A >::allocator_type = typename Data_t::allocator_type

Definition at line 88 of file LazyVector.h.

template<typename T, typename A = typename std::vector<T>::allocator_type>

using util::LazyVector< T, A >::const_pointer = typename Data_t::const_pointer

Definition at line 95 of file LazyVector.h.

template<typename T, typename A = typename std::vector<T>::allocator_type>

using util::LazyVector< T, A >::const_reference = typename Data_t::const_reference

Definition at line 93 of file LazyVector.h.

template<typename T, typename A = typename std::vector<T>::allocator_type>

using util::LazyVector< T, A >::Data_t = std::vector<T, A>

private

Actual data storage type.

Definition at line 80 of file LazyVector.h.

template<typename T, typename A = typename std::vector<T>::allocator_type>

using util::LazyVector< T, A >::difference_type = typename Data_t::difference_type

Definition at line 91 of file LazyVector.h.

template<typename T, typename A = typename std::vector<T>::allocator_type>

using util::LazyVector< T, A >::pointer = typename Data_t::pointer

Definition at line 94 of file LazyVector.h.

template<typename T, typename A = typename std::vector<T>::allocator_type>

using util::LazyVector< T, A >::reference = typename Data_t::reference

Definition at line 92 of file LazyVector.h.

template<typename T, typename A = typename std::vector<T>::allocator_type>

using util::LazyVector< T, A >::size_type = typename Data_t::size_type

Definition at line 90 of file LazyVector.h.

template<typename T, typename A = typename std::vector<T>::allocator_type>

using util::LazyVector< T, A >::value_type = typename Data_t::value_type

Definition at line 89 of file LazyVector.h.

Constructor & Destructor Documentation

template<typename T, typename A = typename std::vector<T>::allocator_type>

util::LazyVector< T, A >::LazyVector ( )

default

— BEGIN Constructors ----------------------------------------------— Default constructor: an empty vector.

template<typename T , typename A >

util::LazyVector< T, A >::LazyVector ( allocator_type const & a )

Constructor: like default, but using the specified allocator.

Definition at line 489 of file LazyVector.h.

490 : fData(a)

491 {}

util::LazyVector::fData

Data_t fData

Actual data storage.

Definition: LazyVector.h:430

template<typename T , typename A >

util::LazyVector< T, A >::LazyVector ( size_type n )

Constructor: a lazy vector with a specified maximum size.

Parameters

n	the initial maximum size of the vector

Note: This constructor is essentially different from the one of STL vector with the same signature.

The vector is set to a nominal size of n, with no stored data.

The default value of vector elements is the default-constructed T value, as returned by defaultValueType().

Definition at line 496 of file LazyVector.h.

497 : LazyVector(n, defaultValueType())

498 {}

util::LazyVector::defaultValueType

static value_type const & defaultValueType()

Returns the class default value (used when user does not specify any).

Definition: LazyVector.h:471

util::LazyVector::LazyVector

LazyVector()=default

n

Char_t n[5]

Definition: comparison_ascii.C:55

template<typename T , typename A >

util::LazyVector< T, A >::LazyVector	(	size_type	n,
		value_type const &	defValue
	)

Constructor: a lazy vector with a specified maximum size.

Parameters

n	the initial maximum size of the vector
defValue	value to be used when resizing

Note: This constructor is essentially different from the one of STL vector with the same signature.

The vector is set to a nominal size of n, with no stored data. A default value defValue is registered, so that it can be used when actual storage is needed for elements whose value is not explicitly specified by the user:

util::LazyVector<int> v(3, 5);
v[0] =  0;
v[2] = -2;
std::cout << "Default element [1]: " << v.at(1) << std::endl;

will print something like: "Default element [1]: 5".

Definition at line 503 of file LazyVector.h.

References util::LazyVector< T, A >::at().

   : fNominalSize(n)
   , fDefValue(defValue)
   {}

Member Function Documentation

template<typename T , typename A >

util::LazyVector< T, A >::value_type util::LazyVector< T, A >::at ( size_type pos ) const

Returns a reference to the specified element, throws an exception if not present.

Parameters

pos	position to be accessed

Returns: a copy of the value of requested element

Exceptions

std::out_of_range if the container is too small to contain pos

Returns a copy of the specified element. If the requested element is beyond the size of the container, an exception std::out_of_range is thrown.

Note: This method differs from the corresponding STL vector in that it returns a copy of the element rather than a reference to it. This happens because the element could not have current storage, and we can't create it because the method is constant.

Definition at line 529 of file LazyVector.h.

References util::LazyVector< T, A >::check_range(), util::LazyVector< T, A >::data_defvalue(), util::LazyVector< T, A >::data_has_index(), util::LazyVector< T, A >::index_of(), and util::LazyVector< T, A >::storage().

Referenced by util::LazyVector< T, A >::at(), util::LazyVector< TF1 >::const_at(), util::LazyVector< TF1 >::data_has_index(), and util::LazyVector< T, A >::LazyVector().

 {
   /*
    * Behaviour summary:
    * * if `pos` is out of vector range, throw an exception
    * * if element at `pos` has no storage, return a copy of the default value
    * * otherwise, return a copy of the element at `pos`
    */
   check_range(pos); // verify that `pos` is valid, throw otherwise
   return data_has_index(pos)? storage()[index_of(pos)]: data_defvalue();
 } // util::LazyVector<T,A>::at() const

template<typename T , typename A >

util::LazyVector< T, A >::reference util::LazyVector< T, A >::at ( size_type pos )

Returns a reference to the specified element, throws an exception if not present.

Parameters

pos	position to be accessed

Returns: the reference to the requested element

Exceptions

std::out_of_range if the container is too small to contain pos

See also: data_defvalue()

Returns a reference to the specified element. If the element is not stored yet, it's created with the default value, and returned. If the requested element is beyond the size of the container, an exception std::out_of_range is thrown.

Definition at line 512 of file LazyVector.h.

References util::LazyVector< T, A >::at(), util::LazyVector< T, A >::check_range(), util::LazyVector< T, A >::expand(), util::LazyVector< T, A >::index_of(), and util::LazyVector< T, A >::storage().

 {
   /*
    * Behaviour summary:
    * * if `pos` is out of vector range, throw an exception
    * * if element at `pos` has no storage, create storage for it
    * * return a reference to the element at `pos`
    */
   check_range(pos); // verify that `pos` is valid, throw otherwise
   expand(pos);
   return storage()[index_of(pos)]; // we already know it's valid
 }

template<typename T , typename A >

void util::LazyVector< T, A >::check_range ( size_type pos ) const

private

Throws std::out_of_range if pos is not contained in the vector.

Definition at line 717 of file LazyVector.h.

References util::LazyVector< T, A >::has_index(), util::LazyVector< T, A >::size(), and util::flags::to_string().

Referenced by util::LazyVector< T, A >::at(), and util::LazyVector< TF1 >::index_of().

                                                          {
   if (has_index(pos)) return;
   throw std::out_of_range(
     "Index " + std::to_string(pos) + " is out of LazyVector range (size: "
     + std::to_string(size()) + ")"
     );
 } // util::LazyVector<T,A>::check_range()

template<typename T , typename A >

void util::LazyVector< T, A >::clear ( )

Removes all stored data and sets the nominal size to 0.

Definition at line 622 of file LazyVector.h.

References util::LazyVector< T, A >::data_clear(), util::LazyVector< T, A >::data_prepare(), and util::LazyVector< T, A >::fNominalSize.

Referenced by phot::PhotonLibrary::CreateEmptyLibrary(), phot::PhotonLibrary::LoadLibraryFromFile(), and util::LazyVector< TF1 >::reserve().

                                 {
   data_clear();
   fNominalSize = 0U;
 } // util::LazyVector<T,A>::clear()

template<typename T, typename A = typename std::vector<T>::allocator_type>

value_type util::LazyVector< T, A >::const_at ( size_type pos ) const

inline

Returns a reference to the specified element, throws an exception if not present.

Parameters

pos	position to be accessed

Returns: a copy of the value of requested element

Exceptions

std::out_of_range if the container is too small to contain pos

Returns a copy of the specified element. If the requested element is beyond the size of the container, an exception std::out_of_range is thrown.

Note: This method differs from the corresponding STL vector in that it returns a copy of the element rather than a reference to it. This happens because the element could not have current storage, and we can't create it because the method is constant.

Definition at line 245 of file LazyVector.h.

245 { return at(pos); }

util::LazyVector::at

value_type at(size_type pos) const

Returns a reference to the specified element, throws an exception if not present. ...

Definition: LazyVector.h:529

template<typename T, typename A = typename std::vector<T>::allocator_type>

value_type util::LazyVector< T, A >::const_get ( size_type pos ) const

inline

Returns a copy of the specified element.

Parameters

pos	position to be accessed

Returns: a copy of the specified element

See also: at(size_type) const

Returns a copy of the specified element. If the requested element is beyond the size of the container, the result is undefined.

Note: See at(value_type) const for an explanation of why a value is returned rather than a reference.

Definition at line 278 of file LazyVector.h.

278 { return this->operator[](pos); }

util::LazyVector::operator[]

value_type operator[](size_type pos) const

Returns a copy of the specified element.

Definition: LazyVector.h:565

template<typename T , typename A >

util::LazyVector< T, A >::const_pointer util::LazyVector< T, A >::data_address ( size_type pos ) const

Returns a constant pointer to the specified element.

Parameters

pos	position of the element

Returns: pointer to storage for specified element, nullptr if not stored

If pos represents an element that has storage, the pointer to that element is returned. If instead pos represents a valid element with no storage (default value), nullptr is returned. If pos does not represent a valid element, the result is undefined.

Definition at line 584 of file LazyVector.h.

References util::LazyVector< T, A >::data_begin_index(), util::LazyVector< T, A >::data_size(), util::LazyVector< T, A >::index_of(), and util::LazyVector< T, A >::storage().

Referenced by util::LazyVector< TF1 >::data_has_index(), phot::PhotonLibrary::GetCounts(), phot::PhotonLibrary::GetReflCounts(), phot::PhotonLibrary::GetReflT0s(), phot::PhotonLibrary::GetTimingPars(), phot::PhotonLibrary::GetTimingTF1s(), and phot::PhotonLibrary::uncheckedAccessTimingTF1().

 {
   /*
    * Behaviour summary:
    * * if `pos` is out of vector range, behaviour is undefined
    * * if element at `pos` has no storage, return nullptr
    * * otherwise, return the pointer to the specified element
    */
   // this implementation will return nullptr if `pos` is out of range;
   // this is not a requirement, and may change at any time.
   if (pos < data_begin_index()) return nullptr;
   auto const index = index_of(pos);
   return (index < data_size())? storage().data() + index: nullptr;
 } // util::LazyVector<T,A>::data_address()

template<typename T, typename A = typename std::vector<T>::allocator_type>

size_type util::LazyVector< T, A >::data_begin_index ( ) const

inline

Index of the first data element in the storage (undefined if data_empty()).

Definition at line 176 of file LazyVector.h.

Referenced by util::LazyVector< T, A >::data_address(), util::LazyVector< TF1 >::data_end_index(), util::LazyVector< TF1 >::data_has_index(), util::LazyVector< T, A >::expand(), util::LazyVector< T, A >::expand_back(), util::LazyVector< T, A >::expand_front(), util::LazyVector< T, A >::operator[](), and util::LazyVector< T, A >::resize().

176 { return fFirstIndex; }

util::LazyVector::fFirstIndex

size_type fFirstIndex

First element currently stored.

Definition: LazyVector.h:433

template<typename T , typename A >

void util::LazyVector< T, A >::data_clear ( )

private

Erases all stored data from the container; nominal size is not changed.

Definition at line 709 of file LazyVector.h.

References util::LazyVector< T, A >::fFirstIndex, and util::LazyVector< T, A >::storage().

Referenced by util::LazyVector< T, A >::clear(), util::LazyVector< T, A >::data_init(), util::LazyVector< T, A >::data_prepare(), util::LazyVector< TF1 >::index_of(), and util::LazyVector< T, A >::resize().

                                      { 
   storage().clear();
   fFirstIndex = storage().max_size();
 } // util::LazyVector<T,A>::data_clear()

template<typename T, typename A = typename std::vector<T>::allocator_type>

value_type const& util::LazyVector< T, A >::data_defvalue ( ) const

inline

Returns the default value.

See also: LazyVector(size_type, value_type const&)

Definition at line 172 of file LazyVector.h.

Referenced by util::LazyVector< T, A >::at(), util::LazyVector< T, A >::data_init(), util::LazyVector< T, A >::expand_back(), util::LazyVector< T, A >::expand_front(), util::LazyVector< T, A >::init(), and util::LazyVector< T, A >::operator[]().

172 { return fDefValue; }

util::LazyVector::fDefValue

value_type fDefValue

Default value.

Definition: LazyVector.h:434

template<typename T, typename A = typename std::vector<T>::allocator_type>

bool util::LazyVector< T, A >::data_empty ( ) const

inlinenoexcept

Returns whether no data is actually stored.

Definition at line 168 of file LazyVector.h.

Referenced by util::LazyVector< T, A >::expand(), and util::LazyVector< T, A >::init().

168 { return fData.empty(); }

util::LazyVector::fData

Data_t fData

Actual data storage.

Definition: LazyVector.h:430

template<typename T, typename A = typename std::vector<T>::allocator_type>

size_type util::LazyVector< T, A >::data_end_index ( ) const

inline

Index after the last data element in the storage (undefined if data_empty()).

Definition at line 180 of file LazyVector.h.

Referenced by util::LazyVector< TF1 >::data_has_index(), util::LazyVector< T, A >::expand(), util::LazyVector< T, A >::expand_back(), util::LazyVector< T, A >::fix_size(), and util::LazyVector< T, A >::resize().

181 { return data_begin_index() + data_size(); }

util::LazyVector::data_begin_index

size_type data_begin_index() const

Definition: LazyVector.h:176

util::LazyVector::data_size

size_type data_size() const noexcept

Returns the size of data actually stored.

Definition: LazyVector.h:162

template<typename T, typename A = typename std::vector<T>::allocator_type>

bool util::LazyVector< T, A >::data_has_index ( size_type pos ) const

inline

Returns the internal storage index for the specified position.

Definition at line 184 of file LazyVector.h.

Referenced by util::LazyVector< T, A >::at(), and util::LazyVector< T, A >::operator[]().

185 { return (pos >= data_begin_index()) && (pos < data_end_index()); }

util::LazyVector::data_begin_index

size_type data_begin_index() const

Definition: LazyVector.h:176

util::LazyVector::data_end_index

size_type data_end_index() const

Definition: LazyVector.h:180

template<typename T , typename A >

void util::LazyVector< T, A >::data_init	(	size_type	startIndex,
		size_type	endIndex
	)

Allocates the specified range and stores default values for it.

Parameters

startIndex	index of the first element to be initialized
endIndex	index after the last element to be initialized

Each element in the range from startIndex to endIndex is stored and the default value is assigned to it.

Old data is lost.

Note: The nominal size of the vector is not changed, therefore the specified range might be not honored. If used in combination with resize(), resize() should be called first.

Definition at line 647 of file LazyVector.h.

References util::LazyVector< T, A >::data_clear(), util::LazyVector< T, A >::data_defvalue(), e, util::LazyVector< T, A >::fFirstIndex, min, util::LazyVector< T, A >::size(), and util::LazyVector< T, A >::storage().

Referenced by util::LazyVector< T, A >::data_prepare(), util::LazyVector< TF1 >::data_prepare(), and phot::PhotonLibrary::LoadLibraryFromFile().

 {
   // we do not go beyond the declared size of the vector:
   size_type const e = std::min(endIndex, size()); 
   if (startIndex >= e) return;
   
   data_clear(); // remove the old data
   storage().resize(e - startIndex, data_defvalue());
   fFirstIndex = startIndex;
   
 } // util::LazyVector<T,A>::data_init(size_type, size_type)

template<typename T, typename A = typename std::vector<T>::allocator_type>

void util::LazyVector< T, A >::data_init ( size_type n )

inline

Allocates and initializes n elements starting from index 0.

Parameters

n	number of elements to be initialized

Each element in the range from 0 to n is stored and the default value is assigned to it. This is semantically similar to std::vector::resize(n, data_defvalue(), except that this method does not change the nominal size of the vector.

Old data is lost.

Note: The nominal size of the vector is not changed, therefore the specified range might be not honored. If used in combination with resize(), resize() should be called first.

Definition at line 422 of file LazyVector.h.

Referenced by util::LazyVector< TF1 >::data_init().

422 { data_init(0U, n); }

util::LazyVector::data_init

void data_init(size_type startIndex, size_type endIndex)

Allocates the specified range and stores default values for it.

Definition: LazyVector.h:647

n

Char_t n[5]

Definition: comparison_ascii.C:55

template<typename T , typename A >

void util::LazyVector< T, A >::data_prepare	(	size_type	startIndex,
		size_type	endIndex
	)

Prepares the vector to store elements in the specified range.

Parameters

startIndex	index of the first element to be stored
endIndex	index after the last element to be stored

See also: data_prepare(size_type)

This method sets the lower index to startIndex, and allocates enough storage to store the whole requested range. The elements are not initialized or constructed, but Following access to elements in the specified range will not cause memory reallocation, and that holds until an access outside that range happens, after which all bets are off.

Old data is lost.

Note: The nominal size of the vector is not changed, therefore the specified range might be not honored. If used in combination with resize(), resize() should be called first.

Definition at line 631 of file LazyVector.h.

References util::LazyVector< T, A >::data_clear(), util::LazyVector< T, A >::data_init(), e, util::LazyVector< T, A >::fFirstIndex, min, util::LazyVector< T, A >::size(), and util::LazyVector< T, A >::storage().

Referenced by util::LazyVector< T, A >::clear(), and util::LazyVector< TF1 >::shrink_to_fit().

 {
   // we do not go beyond the declared size of the vector:
   size_type const e = std::min(endIndex, size()); 
   if (startIndex >= e) return;
   
   data_clear(); // remove the old data
   storage().reserve(e - startIndex);
   fFirstIndex = startIndex;
   
 } // util::LazyVector<T,A>::data_prepare(size_type, size_type)

template<typename T, typename A = typename std::vector<T>::allocator_type>

void util::LazyVector< T, A >::data_prepare ( size_type n )

inline

Prepares the vector to store n elements from 0.

Parameters

n	number of elements to prepare storage for

See also: data_prepare(size_type, size_type)

This method reserves storage for n elements starting with the element #0.

Old data is lost.

See data_prepare(size_type, size_type) for more information.

Definition at line 389 of file LazyVector.h.

Referenced by util::LazyVector< TF1 >::data_prepare().

389 { data_prepare(0U, n); }

util::LazyVector::data_prepare

void data_prepare(size_type startIndex, size_type endIndex)

Prepares the vector to store elements in the specified range.

Definition: LazyVector.h:631

n

Char_t n[5]

Definition: comparison_ascii.C:55

template<typename T, typename A = typename std::vector<T>::allocator_type>

size_type util::LazyVector< T, A >::data_size ( ) const

inlinenoexcept

Returns the size of data actually stored.

Definition at line 162 of file LazyVector.h.

Referenced by util::LazyVector< T, A >::data_address(), util::LazyVector< TF1 >::data_end_index(), and util::LazyVector< T, A >::operator[]().

162 { return fData.size(); }

util::LazyVector::fData

Data_t fData

Actual data storage.

Definition: LazyVector.h:430

template<typename T, typename A = typename std::vector<T>::allocator_type>

static value_type const& util::LazyVector< T, A >::defaultValueType ( )

inlinestaticprivate

Returns the class default value (used when user does not specify any).

Definition at line 471 of file LazyVector.h.

471 { return fDefaultDefaultValue; }

util::LazyVector::fDefaultDefaultValue

static value_type const fDefaultDefaultValue

Default-initialised value of type value_type used as default fallback.

Definition: LazyVector.h:437

template<typename T, typename A = typename std::vector<T>::allocator_type>

bool util::LazyVector< T, A >::empty ( ) const

inlinenoexcept

Returns whether the vector is empty.

Definition at line 159 of file LazyVector.h.

159 { return fNominalSize == 0U; }

util::LazyVector::fNominalSize

size_type fNominalSize

Alleged data size.

Definition: LazyVector.h:432

template<typename T , typename A >

void util::LazyVector< T, A >::expand ( size_type pos )

private

Expands the storage to include the specified position.

Definition at line 662 of file LazyVector.h.

References util::LazyVector< T, A >::data_begin_index(), util::LazyVector< T, A >::data_empty(), util::LazyVector< T, A >::data_end_index(), util::LazyVector< T, A >::expand_back(), util::LazyVector< T, A >::expand_front(), and util::LazyVector< T, A >::init().

Referenced by util::LazyVector< T, A >::at(), util::LazyVector< TF1 >::index_of(), and util::LazyVector< T, A >::operator[]().

                                               {
   // this is just a dispatcher
   if      (data_empty())              init(pos);
   else if (pos <  data_begin_index()) expand_front(pos);
   else if (pos >= data_end_index())   expand_back(pos);
 }

template<typename T , typename A >

void util::LazyVector< T, A >::expand_back ( size_type pos )

private

Expands the storage to include the specified position ahead of it.

Definition at line 692 of file LazyVector.h.

References util::LazyVector< T, A >::data_begin_index(), util::LazyVector< T, A >::data_defvalue(), util::LazyVector< T, A >::data_end_index(), util::LazyVector< T, A >::fix_size(), and util::LazyVector< T, A >::storage().

Referenced by util::LazyVector< T, A >::expand(), and util::LazyVector< TF1 >::index_of().

                                                    {
   assert(pos >= data_end_index());
   storage().resize(pos + 1U - data_begin_index(), data_defvalue());
   fix_size();
 }

template<typename T , typename A >

void util::LazyVector< T, A >::expand_front ( size_type pos )

private

Expands the storage to include the specified position behind it.

Definition at line 682 of file LazyVector.h.

References evd::details::begin(), util::LazyVector< T, A >::data_begin_index(), util::LazyVector< T, A >::data_defvalue(), util::LazyVector< T, A >::fFirstIndex, and util::LazyVector< T, A >::storage().

Referenced by util::LazyVector< T, A >::expand(), and util::LazyVector< TF1 >::index_of().

                                                     {
   assert(pos < data_begin_index());
   storage().insert
     (storage().begin(), data_begin_index() - pos, data_defvalue());
   fFirstIndex = pos;
 }

template<typename T , typename A >

void util::LazyVector< T, A >::fix_size ( )

private

Makes sure the nominal size is large enough to include all stored data.

Definition at line 701 of file LazyVector.h.

References util::LazyVector< T, A >::data_end_index(), and util::LazyVector< T, A >::fNominalSize.

Referenced by util::LazyVector< T, A >::expand_back(), util::LazyVector< TF1 >::index_of(), and util::LazyVector< T, A >::init().

                                   {
   auto const min_size = data_end_index();
   if (fNominalSize < min_size) fNominalSize = min_size;
 }

template<typename T, typename A = typename std::vector<T>::allocator_type>

reference util::LazyVector< T, A >::get ( size_type pos )

inline

Returns a reference to the specified element.

Parameters

pos	position to be accessed

Returns: a reference to the specified element

See also: data_defvalue()

Returns a reference to the specified element. If that element is not stored, it is allocated first; all missing elements, including the required one, are initialised by copying into them the default value stored at construction. Like for STL vector, this method does not expand the vector: if pos is beyond the vector size, the result is undefined.

Definition at line 296 of file LazyVector.h.

296 { return this->operator[](pos); }

util::LazyVector::operator[]

value_type operator[](size_type pos) const

Returns a copy of the specified element.

Definition: LazyVector.h:565

template<typename T, typename A = typename std::vector<T>::allocator_type>

bool util::LazyVector< T, A >::has_index ( size_type pos ) const

inlinenoexcept

Returns whether the specified position is within the vector.

Definition at line 165 of file LazyVector.h.

Referenced by util::LazyVector< T, A >::check_range(), and util::LazyVector< T, A >::operator[]().

165 { return pos < size(); }

util::LazyVector::size

size_type size() const noexcept

Returns the size of the vector.

Definition: LazyVector.h:156

template<typename T, typename A = typename std::vector<T>::allocator_type>

size_type util::LazyVector< T, A >::index_of ( size_type pos ) const

inlineprivate

Returns the internal storage index for the specified position.

Definition at line 446 of file LazyVector.h.

Referenced by util::LazyVector< T, A >::at(), util::LazyVector< T, A >::data_address(), util::LazyVector< T, A >::operator[](), and util::LazyVector< T, A >::resize().

446 { return pos - fFirstIndex; }

util::LazyVector::fFirstIndex

size_type fFirstIndex

First element currently stored.

Definition: LazyVector.h:433

template<typename T , typename A >

void util::LazyVector< T, A >::init	(	size_type	pos,
		size_type	n = `1U`
	)

private

Makes the first data allocation.

Definition at line 672 of file LazyVector.h.

References util::LazyVector< T, A >::data_defvalue(), util::LazyVector< T, A >::data_empty(), util::LazyVector< T, A >::fFirstIndex, util::LazyVector< T, A >::fix_size(), and util::LazyVector< T, A >::storage().

Referenced by util::LazyVector< T, A >::expand(), and util::LazyVector< TF1 >::index_of().

                                                            {
   assert(data_empty());
   storage().assign(n, data_defvalue());
   fFirstIndex = pos;
   fix_size();
 }

template<typename T , typename A >

util::LazyVector< T, A >::value_type util::LazyVector< T, A >::operator[] ( size_type pos ) const

Returns a copy of the specified element.

Parameters

pos	position to be accessed

Returns: a copy of the specified element

See also: at(size_type) const

Returns a copy of the specified element. If the requested element is beyond the size of the container, the result is undefined.

Note: See at(value_type) const for an explanation of why a value is returned rather than a reference.

Definition at line 565 of file LazyVector.h.

References util::LazyVector< T, A >::data_begin_index(), util::LazyVector< T, A >::data_defvalue(), util::LazyVector< T, A >::data_size(), util::LazyVector< T, A >::index_of(), and util::LazyVector< T, A >::storage().

Referenced by util::LazyVector< TF1 >::const_at(), util::LazyVector< TF1 >::const_get(), and util::LazyVector< TF1 >::get().

 {
   /*
    * Behaviour summary:
    * * if `pos` is out of vector range, behaviour is undefined
    * * if element at `pos` has no storage, return a copy of the default value
    * * otherwise, return a copy of the element at `pos`
    */
   // this implementation will return a default value if `pos` is out of range;
   // this is not a requirement, and may change at any time.
   if (pos < data_begin_index()) return data_defvalue();
   auto const index = index_of(pos);
   return (index < data_size())? storage()[index]: data_defvalue();
 } // util::LazyVector<T,A>::operator[] () const

template<typename T , typename A >

util::LazyVector< T, A >::reference util::LazyVector< T, A >::operator[] ( size_type pos )

Returns a reference to the specified element.

Parameters

pos	position to be accessed

Returns: a reference to the specified element

See also: data_defvalue()

Returns a reference to the specified element. If that element is not stored, it is allocated first; all missing elements, including the required one, are initialised by copying into them the default value stored at construction. Like for STL vector, this method does not expand the vector: if pos is beyond the vector size, the result is undefined.

Definition at line 545 of file LazyVector.h.

References util::LazyVector< T, A >::data_has_index(), util::LazyVector< T, A >::expand(), util::LazyVector< T, A >::has_index(), util::LazyVector< T, A >::index_of(), and util::LazyVector< T, A >::storage().

 {
   /*
    * Behaviour summary:
    * * if `pos` is out of vector range, behaviour is undefined
    * * if element at `pos` has no storage, create storage for it
    * * return a reference to the element at `pos`
    */
   // to have the common case where the requested position has storage be handled
   // the fastest, we "enforce" the order by nesting (optimiser has last word)
   if (!data_has_index(pos)) {
     if (has_index(pos)) expand(pos);
   }
   return storage()[index_of(pos)];
 } // util::LazyVector<T,A>::operator[]()

template<typename T, typename A = typename std::vector<T>::allocator_type>

void util::LazyVector< T, A >::reserve ( size_type n )

inline

Allocates enough memory in storage to store n elements.

Parameters

n	number of elements to have storage for

See also: data_prepare()

Storage allocation is resized to be able to host at least n elements (it is not reduced). Note that the use of reserve() for LazyVector is more subtle than for a STL vector. The common use of reserve() is to avoid reallocations when extending the vector. In this case, after a call to reserve(n) the reallocation is avoided only as long as only the elements from data_begin_index() to data_begin_index() + n (excluded) are written.

Note that data_prepare() has a similar purpose and might be more effective.

Definition at line 348 of file LazyVector.h.

348 { storage().reserve(n); }

util::LazyVector::storage

Data_t & storage()

Returns the data storage.

Definition: LazyVector.h:441

n

Char_t n[5]

Definition: comparison_ascii.C:55

template<typename T , typename A >

void util::LazyVector< T, A >::resize ( size_type newSize )

Changes the nominal size of the container.

Parameters

newSize new container size

The nominal size of the vector is set to newSize. Even when newSize is larger than the current nominal size, no additional data is stored. If the new nominal size is smaller, actual data may be released (i.e. erased) so that no stored data is beyond the new nominal size.

Note: It is not possible to specify a filling value: the "default" value specified on construction is always used.

Definition at line 602 of file LazyVector.h.

References evd::details::begin(), util::LazyVector< T, A >::data_begin_index(), util::LazyVector< T, A >::data_clear(), util::LazyVector< T, A >::data_end_index(), evd::details::end(), util::LazyVector< T, A >::fNominalSize, util::LazyVector< T, A >::index_of(), and util::LazyVector< T, A >::storage().

Referenced by phot::PhotonLibrary::CreateEmptyLibrary(), util::LazyVector< TF1 >::get(), and phot::PhotonLibrary::LoadLibraryFromFile().

                                                   {
   /*
    * Behaviour summary:
    * * when extending, do not change storage
    * * when shrinking, cut the excess storage
    */
   fNominalSize = newSize;
   // delete any excess data
   if (data_end_index() > newSize) {
     if (fNominalSize <= data_begin_index()) data_clear(); // no data is left
     else {
       storage().erase
         (storage().begin() + index_of(fNominalSize), storage().end());
     }
   }
 } // util::LazyVector<T,A>::resize()