class InlinedVector

Creates an empty inlined vector with a value-initialized allocator.

Creates an empty inlined vector with a copy of `allocator`.

Creates an inlined vector with `n` copies of `value_type()`.

Creates an inlined vector with `n` copies of `v`.

Creates an inlined vector with copies of the elements of `list`.

Creates an inlined vector with elements constructed from the provided

forward iterator range [`first`, `last`).

NOTE: the `enable_if` prevents ambiguous interpretation between a call to

this constructor with two integral arguments and a call to the above

`InlinedVector(size_type, const_reference)` constructor.

Creates an inlined vector with elements constructed from the provided input

iterator range [`first`, `last`).

Creates an inlined vector by copying the contents of `other` using

`other`'s allocator.

Creates an inlined vector by copying the contents of `other` using the

provided `allocator`.

Creates an inlined vector by moving in the contents of `other` without

allocating. If `other` contains allocated memory, the newly-created inlined

vector will take ownership of that memory. However, if `other` does not

contain allocated memory, the newly-created inlined vector will perform

element-wise move construction of the contents of `other`.

NOTE: since no allocation is performed for the inlined vector in either

case, the `noexcept(...)` specification depends on whether moving the

underlying objects can throw. It is assumed assumed that...

a) move constructors should only throw due to allocation failure.

b) if `value_type`'s move constructor allocates, it uses the same

allocation function as the inlined vector's allocator.

Thus, the move constructor is non-throwing if the allocator is non-throwing

or `value_type`'s move constructor is specified as `noexcept`.

Creates an inlined vector by moving in the contents of `other` with a copy

of `allocator`.

NOTE: if `other`'s allocator is not equal to `allocator`, even if `other`

contains allocated memory, this move constructor will still allocate. Since

allocation is performed, this constructor can only be `noexcept` if the

specified allocator is also `noexcept`.

`InlinedVector::empty()`

Returns whether the inlined vector contains no elements.

`InlinedVector::size()`

Returns the number of elements in the inlined vector.

`InlinedVector::max_size()`

Returns the maximum number of elements the inlined vector can hold.

`InlinedVector::capacity()`

Returns the number of elements that could be stored in the inlined vector

without requiring a reallocation.

NOTE: for most inlined vectors, `capacity()` should be equal to the

template parameter `N`. For inlined vectors which exceed this capacity,

they will no longer be inlined and `capacity()` will equal the capactity of

the allocated memory.

`InlinedVector::data()`

Returns a `pointer` to the elements of the inlined vector. This pointer

can be used to access and modify the contained elements.

NOTE: only elements within [`data()`, `data() + size()`) are valid.

Overload of `InlinedVector::data()` that returns a `const_pointer` to the

elements of the inlined vector. This pointer can be used to access but not

modify the contained elements.

NOTE: only elements within [`data()`, `data() + size()`) are valid.

`InlinedVector::operator[](...)`

Returns a `reference` to the `i`th element of the inlined vector.

Overload of `InlinedVector::operator[](...)` that returns a

`const_reference` to the `i`th element of the inlined vector.

`InlinedVector::at(...)`

Returns a `reference` to the `i`th element of the inlined vector.

NOTE: if `i` is not within the required range of `InlinedVector::at(...)`,

in both debug and non-debug builds, `std::out_of_range` will be thrown.

Overload of `InlinedVector::at(...)` that returns a `const_reference` to

the `i`th element of the inlined vector.

NOTE: if `i` is not within the required range of `InlinedVector::at(...)`,

in both debug and non-debug builds, `std::out_of_range` will be thrown.

`InlinedVector::front()`

Returns a `reference` to the first element of the inlined vector.

Overload of `InlinedVector::front()` that returns a `const_reference` to

the first element of the inlined vector.

`InlinedVector::back()`

Returns a `reference` to the last element of the inlined vector.

Overload of `InlinedVector::back()` that returns a `const_reference` to the

last element of the inlined vector.

`InlinedVector::begin()`

Returns an `iterator` to the beginning of the inlined vector.

Overload of `InlinedVector::begin()` that returns a `const_iterator` to

the beginning of the inlined vector.

`InlinedVector::end()`

Returns an `iterator` to the end of the inlined vector.

Overload of `InlinedVector::end()` that returns a `const_iterator` to the

end of the inlined vector.

`InlinedVector::cbegin()`

Returns a `const_iterator` to the beginning of the inlined vector.

`InlinedVector::cend()`

Returns a `const_iterator` to the end of the inlined vector.

`InlinedVector::rbegin()`

Returns a `reverse_iterator` from the end of the inlined vector.

Overload of `InlinedVector::rbegin()` that returns a

`const_reverse_iterator` from the end of the inlined vector.

`InlinedVector::rend()`

Returns a `reverse_iterator` from the beginning of the inlined vector.

Overload of `InlinedVector::rend()` that returns a `const_reverse_iterator`

from the beginning of the inlined vector.

`InlinedVector::crbegin()`

Returns a `const_reverse_iterator` from the end of the inlined vector.

`InlinedVector::crend()`

Returns a `const_reverse_iterator` from the beginning of the inlined

vector.

`InlinedVector::get_allocator()`

Returns a copy of the inlined vector's allocator.

`InlinedVector::operator=(...)`

Replaces the elements of the inlined vector with copies of the elements of

`list`.

Overload of `InlinedVector::operator=(...)` that replaces the elements of

the inlined vector with copies of the elements of `other`.

Overload of `InlinedVector::operator=(...)` that moves the elements of

`other` into the inlined vector.

NOTE: as a result of calling this overload, `other` is left in a valid but

unspecified state.

`InlinedVector::assign(...)`

Replaces the contents of the inlined vector with `n` copies of `v`.

Overload of `InlinedVector::assign(...)` that replaces the contents of the

inlined vector with copies of the elements of `list`.

Overload of `InlinedVector::assign(...)` to replace the contents of the

inlined vector with the range [`first`, `last`).

NOTE: this overload is for iterators that are "forward" category or better.

Overload of `InlinedVector::assign(...)` to replace the contents of the

inlined vector with the range [`first`, `last`).

NOTE: this overload is for iterators that are "input" category.

`InlinedVector::resize(...)`

Resizes the inlined vector to contain `n` elements.

NOTE: If `n` is smaller than `size()`, extra elements are destroyed. If `n`

is larger than `size()`, new elements are value-initialized.

Overload of `InlinedVector::resize(...)` that resizes the inlined vector to

contain `n` elements.

NOTE: if `n` is smaller than `size()`, extra elements are destroyed. If `n`

is larger than `size()`, new elements are copied-constructed from `v`.

`InlinedVector::insert(...)`

Inserts a copy of `v` at `pos`, returning an `iterator` to the newly

inserted element.

Overload of `InlinedVector::insert(...)` that inserts `v` at `pos` using

move semantics, returning an `iterator` to the newly inserted element.

Overload of `InlinedVector::insert(...)` that inserts `n` contiguous copies

of `v` starting at `pos`, returning an `iterator` pointing to the first of

the newly inserted elements.

Overload of `InlinedVector::insert(...)` that inserts copies of the

elements of `list` starting at `pos`, returning an `iterator` pointing to

the first of the newly inserted elements.

Overload of `InlinedVector::insert(...)` that inserts the range [`first`,

`last`) starting at `pos`, returning an `iterator` pointing to the first

of the newly inserted elements.

NOTE: this overload is for iterators that are "forward" category or better.

Overload of `InlinedVector::insert(...)` that inserts the range [`first`,

`last`) starting at `pos`, returning an `iterator` pointing to the first

of the newly inserted elements.

NOTE: this overload is for iterators that are "input" category.

`InlinedVector::emplace(...)`

Constructs and inserts an element using `args...` in the inlined vector at

`pos`, returning an `iterator` pointing to the newly emplaced element.

`InlinedVector::emplace_back(...)`

Constructs and inserts an element using `args...` in the inlined vector at

`end()`, returning a `reference` to the newly emplaced element.

`InlinedVector::push_back(...)`

Inserts a copy of `v` in the inlined vector at `end()`.

Overload of `InlinedVector::push_back(...)` for inserting `v` at `end()`

using move semantics.

`InlinedVector::pop_back()`

Destroys the element at `back()`, reducing the size by `1`.

`InlinedVector::erase(...)`

Erases the element at `pos`, returning an `iterator` pointing to where the

erased element was located.

NOTE: may return `end()`, which is not dereferenceable.

Overload of `InlinedVector::erase(...)` that erases every element in the

range [`from`, `to`), returning an `iterator` pointing to where the first

erased element was located.

NOTE: may return `end()`, which is not dereferenceable.

`InlinedVector::clear()`

Destroys all elements in the inlined vector, setting the size to `0` and

deallocating any held memory.

`InlinedVector::reserve(...)`

Ensures that there is enough room for at least `n` elements.

`InlinedVector::shrink_to_fit()`

Attempts to reduce memory usage by moving elements to (or keeping elements

in) the smallest available buffer sufficient for containing `size()`

elements.

If `size()` is sufficiently small, the elements will be moved into (or kept

in) the inlined space.

`InlinedVector::swap(...)`

Swaps the contents of the inlined vector with `other`.