template<typename InIt> void assign(InIt first, InIt last);

void assign(std::initializer_list< T > il);

Effects: Assigns the the range [il.begin(), il.end()) to *this.

Throws: If memory allocation throws or T's constructor from dereferencing iniializer_list iterator throws.

template<typename FwdIt> void assign(FwdIt first, FwdIt last);

Effects: Assigns the the range [first, last) to *this.

Throws: If memory allocation throws or T's copy/move constructor/assignment or T's constructor/assignment from dereferencing InpIt throws.

Complexity: Linear to n.

void assign(size_type n, const value_type & val);

Effects: Assigns the n copies of val to *this.

Throws: If memory allocation throws or T's copy/move constructor/assignment throws.

Complexity: Linear to n.

allocator_type get_allocator() const noexcept;

Effects: Returns a copy of the internal allocator.

Throws: If allocator's copy constructor throws.

Complexity: Constant.

stored_allocator_type & get_stored_allocator() noexcept;

Effects: Returns a reference to the internal allocator.

Throws: Nothing

Complexity: Constant.

Note: Non-standard extension.

const stored_allocator_type & get_stored_allocator() const noexcept;

Effects: Returns a reference to the internal allocator.

Throws: Nothing

Complexity: Constant.

Note: Non-standard extension.

iterator begin() noexcept;

Effects: Returns an iterator to the first element contained in the vector.

Throws: Nothing.

Complexity: Constant.

const_iterator begin() const noexcept;

Effects: Returns a const_iterator to the first element contained in the vector.

Throws: Nothing.

Complexity: Constant.

iterator end() noexcept;

Effects: Returns an iterator to the end of the vector.

Throws: Nothing.

Complexity: Constant.

const_iterator end() const noexcept;

Effects: Returns a const_iterator to the end of the vector.

Throws: Nothing.

Complexity: Constant.

reverse_iterator rbegin() noexcept;

Effects: Returns a reverse_iterator pointing to the beginning of the reversed vector.

Throws: Nothing.

Complexity: Constant.

const_reverse_iterator rbegin() const noexcept;

Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed vector.

Throws: Nothing.

Complexity: Constant.

reverse_iterator rend() noexcept;

Effects: Returns a reverse_iterator pointing to the end of the reversed vector.

Throws: Nothing.

Complexity: Constant.

const_reverse_iterator rend() const noexcept;

Effects: Returns a const_reverse_iterator pointing to the end of the reversed vector.

Throws: Nothing.

Complexity: Constant.

const_iterator cbegin() const noexcept;

Effects: Returns a const_iterator to the first element contained in the vector.

Throws: Nothing.

Complexity: Constant.

const_iterator cend() const noexcept;

Effects: Returns a const_iterator to the end of the vector.

Throws: Nothing.

Complexity: Constant.

const_reverse_iterator crbegin() const noexcept;

Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed vector.

Throws: Nothing.

Complexity: Constant.

const_reverse_iterator crend() const noexcept;

Effects: Returns a const_reverse_iterator pointing to the end of the reversed vector.

Throws: Nothing.

Complexity: Constant.

bool empty() const noexcept;

Effects: Returns true if the vector contains no elements.

Throws: Nothing.

Complexity: Constant.

size_type size() const noexcept;

Effects: Returns the number of the elements contained in the vector.

Throws: Nothing.

Complexity: Constant.

size_type max_size() const noexcept;

Effects: Returns the largest possible size of the vector.

Throws: Nothing.

Complexity: Constant.

void resize(size_type new_size);

Effects: Inserts or erases elements at the end such that the size becomes n. New elements are value initialized.

Throws: If memory allocation throws, or T's copy/move or value initialization throws.

Complexity: Linear to the difference between size() and new_size.

void resize(size_type new_size, default_init_t);

Effects: Inserts or erases elements at the end such that the size becomes n. New elements are default initialized.

Throws: If memory allocation throws, or T's copy/move or default initialization throws.

Complexity: Linear to the difference between size() and new_size.

Note: Non-standard extension

void resize(size_type new_size, const T & x);

Effects: Inserts or erases elements at the end such that the size becomes n. New elements are copy constructed from x.

Throws: If memory allocation throws, or T's copy/move constructor throws.

Complexity: Linear to the difference between size() and new_size.

size_type capacity() const noexcept;

Effects: Number of elements for which memory has been allocated. capacity() is always greater than or equal to size().

Throws: Nothing.

Complexity: Constant.

void reserve(size_type new_cap);

Effects: If n is less than or equal to capacity(), this call has no effect. Otherwise, it is a request for allocation of additional memory. If the request is successful, then capacity() is greater than or equal to n; otherwise, capacity() is unchanged. In either case, size() is unchanged.

Throws: If memory allocation allocation throws or T's copy/move constructor throws.

void shrink_to_fit();

Effects: Tries to deallocate the excess of memory created with previous allocations. The size of the vector is unchanged

Throws: If memory allocation throws, or T's copy/move constructor throws.

Complexity: Linear to size().

reference front() noexcept;

Requires: !empty()

Effects: Returns a reference to the first element of the container.

Throws: Nothing.

Complexity: Constant.

const_reference front() const noexcept;

Requires: !empty()

Effects: Returns a const reference to the first element of the container.

Throws: Nothing.

Complexity: Constant.

reference back() noexcept;

Requires: !empty()

Effects: Returns a reference to the last element of the container.

Throws: Nothing.

Complexity: Constant.

const_reference back() const noexcept;

Requires: !empty()

Effects: Returns a const reference to the last element of the container.

Throws: Nothing.

Complexity: Constant.

reference operator[](size_type n) noexcept;

Requires: size() > n.

Effects: Returns a reference to the nth element from the beginning of the container.

Throws: Nothing.

Complexity: Constant.

const_reference operator[](size_type n) const noexcept;

Requires: size() > n.

Effects: Returns a const reference to the nth element from the beginning of the container.

Throws: Nothing.

Complexity: Constant.

iterator nth(size_type n) noexcept;

Requires: size() >= n.

Effects: Returns an iterator to the nth element from the beginning of the container. Returns end() if n == size().

Throws: Nothing.

Complexity: Constant.

Note: Non-standard extension

const_iterator nth(size_type n) const noexcept;

Requires: size() >= n.

Effects: Returns a const_iterator to the nth element from the beginning of the container. Returns end() if n == size().

Throws: Nothing.

Complexity: Constant.

Note: Non-standard extension

size_type index_of(iterator p) noexcept;

Requires: begin() <= p <= end().

Effects: Returns the index of the element pointed by p and size() if p == end().

Throws: Nothing.

Complexity: Constant.

Note: Non-standard extension

size_type index_of(const_iterator p) const noexcept;

Requires: begin() <= p <= end().

Effects: Returns the index of the element pointed by p and size() if p == end().

Throws: Nothing.

Complexity: Constant.

Note: Non-standard extension

reference at(size_type n);

Requires: size() > n.

Effects: Returns a reference to the nth element from the beginning of the container.

Throws: range_error if n >= size()

Complexity: Constant.

const_reference at(size_type n) const;

Requires: size() > n.

Effects: Returns a const reference to the nth element from the beginning of the container.

Throws: range_error if n >= size()

Complexity: Constant.

T * data() noexcept;

Returns: A pointer such that [data(),data() + size()) is a valid range. For a non-empty vector, data() == &front().

Throws: Nothing.

Complexity: Constant.

const T * data() const noexcept;

Returns: A pointer such that [data(),data() + size()) is a valid range. For a non-empty vector, data() == &front().

Throws: Nothing.

Complexity: Constant.

template<class ... Args> reference emplace_back(Args &&... args);

Effects: Inserts an object of type T constructed with std::forward<Args>(args)... in the end of the vector.

Returns: A reference to the created object.

Throws: If memory allocation throws or the in-place constructor throws or T's copy/move constructor throws.

Complexity: Amortized constant time.

template<class ... Args> bool stable_emplace_back(Args &&... args);

Effects: Inserts an object of type T constructed with std::forward<Args>(args)... in the end of the vector.

Throws: If the in-place constructor throws.

Complexity: Constant time.

Note: Non-standard extension.

template<class ... Args> reference unchecked_emplace_back(Args &&... args);

Requires: Before the call to this function size() < capacity() must be true. Otherwise, the behavior is undefined.

Effects: Inserts an object of type T constructed with std::forward<Args>(args)... in the end of the vector.

Throws: If the in-place constructor throws.

Complexity: Constant time.

Note: Non-standard extension.

template<class ... Args> 
  iterator emplace(const_iterator position, Args &&... args);

Requires: position must be a valid iterator of *this.

Effects: Inserts an object of type T constructed with std::forward<Args>(args)... before position

Throws: If memory allocation throws or the in-place constructor throws or T's copy/move constructor/assignment throws.

Complexity: If position is end(), amortized constant time Linear time otherwise.

void push_back(const T & x);

Effects: Inserts a copy of x at the end of the vector.

Throws: If memory allocation throws or T's copy/move constructor throws.

Complexity: Amortized constant time.

void push_back(T && x);

Effects: Constructs a new element in the end of the vector and moves the resources of x to this new element.

Throws: If memory allocation throws or T's copy/move constructor throws.

Complexity: Amortized constant time.

void unchecked_push_back(const T & x);

Requires: Before the call to this function size() < capacity() must be true. Otherwise, the behavior is undefined.

Effects: Inserts a copy of x at the end of the vector.

Throws: If T's copy/move constructor throws.

Complexity: Constant time.

void unchecked_push_back(T && x);

Requires: Before the call to this function size() < capacity() must be true. Otherwise, the behavior is undefined.

Effects: Constructs a new element in the end of the vector and moves the resources of x to this new element.

Throws: If T's copy/move constructor throws.

Complexity: Constant time.

iterator insert(const_iterator position, const T & x);

Requires: position must be a valid iterator of *this.

Effects: Insert a copy of x before position.

Throws: If memory allocation throws or T's copy/move constructor/assignment throws.

Complexity: If position is end(), amortized constant time Linear time otherwise.

iterator insert(const_iterator position, T && x);

Requires: position must be a valid iterator of *this.

Effects: Insert a new element before position with x's resources.

Throws: If memory allocation throws.

Complexity: If position is end(), amortized constant time Linear time otherwise.

iterator insert(const_iterator p, size_type n, const T & x);

Requires: p must be a valid iterator of *this.

Effects: Insert n copies of x before pos.

Returns: an iterator to the first inserted element or p if n is 0.

Throws: If memory allocation throws or T's copy/move constructor throws.

Complexity: Linear to n.

template<typename InIt> 
  iterator insert(const_iterator pos, InIt first, InIt last);

Requires: p must be a valid iterator of *this.

Effects: Insert a copy of the [first, last) range before pos.

Returns: an iterator to the first inserted element or pos if first == last.

Throws: If memory allocation throws, T's constructor from a dereferenced InpIt throws or T's copy/move constructor/assignment throws.

Complexity: Linear to boost::container::iterator_distance [first, last).

iterator insert(const_iterator position, 
                std::initializer_list< value_type > il);

Requires: p must be a valid iterator of *this. num, must be equal to boost::container::iterator_distance(first, last)

Effects: Insert a copy of the [first, last) range before pos.

Returns: an iterator to the first inserted element or pos if first == last.

Throws: If memory allocation throws, T's constructor from a dereferenced InpIt throws or T's copy/move constructor/assignment throws.

Complexity: Linear to boost::container::iterator_distance [first, last).

Note: This function avoids a linear operation to calculate boost::container::iterator_distance[first, last) for forward and bidirectional iterators, and a one by one insertion for input iterators. This is a a non-standard extension.

Requires: position must be a valid iterator of *this.

Effects: Insert a copy of the [il.begin(), il.end()) range before position.

Returns: an iterator to the first inserted element or position if first == last.

Complexity: Linear to the range [il.begin(), il.end()).

Requires: position must be a valid iterator of *this.

Effects: Insert a copy of the [il.begin(), il.end()) range before position.

Returns: an iterator to the first inserted element or position if first == last.

Complexity: Linear to the range [il.begin(), il.end()).

void pop_back() noexcept;

Effects: Removes the last element from the container.

Throws: Nothing.

Complexity: Constant time.

iterator erase(const_iterator position);

Effects: Erases the element at position pos.

Throws: Nothing.

Complexity: Linear to the elements between pos and the last element. Constant if pos is the last element.

iterator erase(const_iterator first, const_iterator last);

Effects: Erases the elements pointed by [first, last).

Throws: Nothing.

Complexity: Linear to the distance between first and last plus linear to the elements between pos and the last element.

void clear() noexcept;

Effects: Erases all the elements of the vector. Leaves the capacity() of the vector unchanged.

Throws: Nothing.

Complexity: Linear to the number of elements in the container.

small_vector_base & operator=(const small_vector_base & other);

Effects: Makes *this contain the same elements as other.

Throws: If memory allocation throws or T's copy/move constructor/assignment throws.

Complexity: Linear to the number of elements in other.

small_vector_base & operator=(small_vector_base && other);

Effects: Move assignment. Transfers other's elements to *this. If the source is using its internal storage, elements are moved one by one; otherwise resources are stolen.

Throws: If T's move constructor/assignment throws when elements must be moved.

Complexity: Linear to the number of elements in the internal storage, constant otherwise.

void swap(small_vector_base & other);

Effects: Swaps the contents of *this and other.

Throws: Nothing unless elements must be moved between buffers and T's move throws.

Complexity: Constant if both use heap storage, linear in the small buffers otherwise.