|
| | Prealloced_array (PSI_memory_key psi_key) |
| |
| | Prealloced_array (PSI_memory_key psi_key, size_t initial_size) |
| | Initializes (parts of) the array with default values. More...
|
| |
| | Prealloced_array (const Prealloced_array &that) |
| | An object instance "owns" its array, so we do deep copy here. More...
|
| |
| | Prealloced_array (Prealloced_array &&that) |
| |
| | Prealloced_array (PSI_memory_key psi_key, const_iterator first, const_iterator last) |
| | Range constructor. More...
|
| |
| | Prealloced_array (std::initializer_list< Element_type > elems) |
| |
| Prealloced_array & | operator= (const Prealloced_array &that) |
| | Copies all the elements from 'that' into this container. More...
|
| |
| Prealloced_array & | operator= (Prealloced_array &&that) |
| |
| | ~Prealloced_array () |
| | Runs DTOR on all elements if needed. More...
|
| |
| size_t | capacity () const |
| |
| size_t | element_size () const |
| |
| bool | empty () const |
| |
| size_t | size () const |
| |
| Element_type & | at (size_t n) |
| |
| const Element_type & | at (size_t n) const |
| |
| Element_type & | operator[] (size_t n) |
| |
| const Element_type & | operator[] (size_t n) const |
| |
| Element_type & | back () |
| |
| const Element_type & | back () const |
| |
| Element_type & | front () |
| |
| const Element_type & | front () const |
| |
| iterator | begin () |
| | begin : Returns a pointer to the first element in the array. More...
|
| |
| iterator | end () |
| |
| const_iterator | begin () const |
| |
| const_iterator | end () const |
| |
| const_iterator | cbegin () const |
| | Returns a constant pointer to the first element in the array. More...
|
| |
| const_iterator | cend () const |
| | Returns a constant pointer to the past-the-end element in the array. More...
|
| |
| bool | assign_at (size_t n, const value_type &val) |
| | Assigns a value to an arbitrary element, even where n >= size(). More...
|
| |
| bool | reserve (size_t n) |
| | Reserves space for array elements. More...
|
| |
| void | claim_memory_ownership (bool claim) |
| | Claim memory ownership. More...
|
| |
| bool | push_back (const Element_type &element) |
| | Copies an element into the back of the array. More...
|
| |
| bool | push_back (Element_type &&element) |
| | Copies (or moves, if possible) an element into the back of the array. More...
|
| |
| template<typename... Args> |
| bool | emplace_back (Args &&...args) |
| | Constructs an element at the back of the array. More...
|
| |
| void | pop_back () |
| | Removes the last element in the array, effectively reducing the container size by one. More...
|
| |
| iterator | insert (const_iterator position, const value_type &val) |
| | The array is extended by inserting a new element before the element at the specified position. More...
|
| |
| iterator | insert (const_iterator position, value_type &&val) |
| | The array is extended by inserting a new element before the element at the specified position. More...
|
| |
| template<typename... Args> |
| iterator | emplace (const_iterator position, Args &&...args) |
| | The array is extended by inserting a new element before the element at the specified position. More...
|
| |
| std::pair< iterator, bool > | insert_unique (const value_type &val) |
| | Similar to std::set<>::insert() Extends the array by inserting a new element, but only if it cannot be found in the array already. More...
|
| |
| size_type | erase_unique (const value_type &val) |
| | Similar to std::set<>::erase() Removes a single element from the array by value. More...
|
| |
| size_type | count_unique (const value_type &val) const |
| | Similar to std::set<>::count() More...
|
| |
| iterator | erase (const_iterator position) |
| | Removes a single element from the array. More...
|
| |
| iterator | erase (size_t ix) |
| | Removes a single element from the array. More...
|
| |
| void | erase_at_end (const_iterator first) |
| | Removes tail elements from the array. More...
|
| |
| iterator | erase (const_iterator first, const_iterator last) |
| | Removes a range of elements from the array. More...
|
| |
| void | swap (Prealloced_array &rhs) |
| | Exchanges the content of the container by the content of rhs, which is another vector object of the same type. More...
|
| |
| void | shrink_to_fit () |
| | Requests the container to reduce its capacity to fit its size. More...
|
| |
| void | resize (size_t n, const Element_type &val=Element_type()) |
| | Resizes the container so that it contains n elements. More...
|
| |
| void | clear () |
| | Removes (and destroys) all elements. More...
|
| |
template<typename Element_type, size_t Prealloc>
class Prealloced_array< Element_type, Prealloc >
A typesafe replacement for DYNAMIC_ARRAY.
We do our own memory management, and pre-allocate space for a number of elements. The purpose is to pre-allocate enough elements to cover normal use cases, thus saving malloc()/free() overhead. If we run out of space, we use malloc to allocate more space.
The interface is chosen to be similar to std::vector. We keep the std::vector property that storage is contiguous.
We have fairly low overhead over the inline storage; typically 8 bytes (e.g. Prealloced_array<TABLE *, 4> needs 40 bytes on 64-bit platforms).
- Template Parameters
-
| Element_type | The type of the elements of the container. Elements must be copyable or movable. |
| Prealloc | Number of elements to pre-allocate. |
template<typename Element_type , size_t Prealloc>
template<typename... Args>
The array is extended by inserting a new element before the element at the specified position.
The element is constructed in-place.
This is generally an inefficient operation, since we need to copy elements to make a new "hole" in the array.
We use std::rotate to move objects, hence Element_type must be move-assignable and move-constructible.
- Returns
- an iterator pointing to the inserted value
template<typename Element_type , size_t Prealloc>
Removes a range of elements from the array.
The removed elements are destroyed. This effectively reduces the containers size by 'last - first'.
This is generally an inefficient operation, since we need to move or copy elements to fill the "hole" in the array.
We use std::move to move objects, hence Element_type must be move-assignable.
template<typename Element_type , size_t Prealloc>
Removes a single element from the array.
The removed element is destroyed. This effectively reduces the container size by one.
This is generally an inefficient operation, since we need to move or copy elements to fill the "hole" in the array.
We use std::move to move objects, hence Element_type must be move-assignable.
template<typename Element_type , size_t Prealloc>
Similar to std::set<>::erase() Removes a single element from the array by value.
The removed element is destroyed. This effectively reduces the container size by one.
This is generally an inefficient operation, since we need to copy elements to fill the "hole" in the array.
Assumes that the array is sorted with std::less<Element_type>.
- Return values
-
| number | of elements removed, 0 or 1. |
template<typename Element_type , size_t Prealloc>
The array is extended by inserting a new element before the element at the specified position.
The element is moved into the array, if possible.
This is generally an inefficient operation, since we need to copy elements to make a new "hole" in the array.
We use std::rotate to move objects, hence Element_type must be move-assignable and move-constructible.
- Returns
- an iterator pointing to the inserted value
template<typename Element_type , size_t Prealloc>
| void Prealloced_array< Element_type, Prealloc >::resize |
( |
size_t |
n, |
|
|
const Element_type & |
val = Element_type() |
|
) |
| |
|
inline |
Resizes the container so that it contains n elements.
If n is smaller than the current container size, the content is reduced to its first n elements, removing those beyond (and destroying them).
If n is greater than the current container size, the content is expanded by inserting at the end as many elements as needed to reach a size of n. If val is specified, the new elements are initialized as copies of val, otherwise, they are value-initialized.
If n is also greater than the current container capacity, an automatic reallocation of the allocated storage space takes place.
Notice that this function changes the actual content of the container by inserting or erasing elements from it.
1.9.2