#include <small_vector.h>

Inheritance diagram for PLMD::gch::small_vector< T, InlineCapacity, Allocator >:

[legend]

Public Types
using	allocator_type = Allocator

using	const_iterator = small_vector_iterator<const_pointer, difference_type>

using	const_pointer = typename std::allocator_traits<allocator_type>::const_pointer

using	const_reference = const value_type&

using	const_reverse_iterator = std::reverse_iterator<const_iterator>

using	difference_type = typename base::difference_type

using	iterator = small_vector_iterator<pointer, difference_type>

using	pointer = typename std::allocator_traits<allocator_type>::pointer

using	reference = value_type&

using	reverse_iterator = std::reverse_iterator<iterator>

using	size_type = typename base::size_type

using	value_type = T

Public Member Functions
PLUMED_GCH_CPP20_CONSTEXPR	small_vector (const allocator_type &alloc) noexcept

PLUMED_GCH_CPP20_CONSTEXPR	small_vector (const small_vector &other)

PLUMED_GCH_CPP20_CONSTEXPR	small_vector (const small_vector &other, const allocator_type &alloc)

template<unsigned I>
PLUMED_GCH_CPP20_CONSTEXPR	small_vector (const small_vector< T, I, Allocator > &other)

template<unsigned I>
PLUMED_GCH_CPP20_CONSTEXPR	small_vector (const small_vector< T, I, Allocator > &other, const allocator_type &alloc)

template<typename InputIt, typename std::enable_if< std::is_base_of< std::input_iterator_tag, typename std::iterator_traits< InputIt >::iterator_category >::value >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR	small_vector (InputIt first, InputIt last, const allocator_type &alloc=allocator_type())

PLUMED_GCH_CPP20_CONSTEXPR	small_vector (size_type count, const allocator_type &alloc=allocator_type())

PLUMED_GCH_CPP20_CONSTEXPR	small_vector (size_type count, const_reference value, const allocator_type &alloc=allocator_type())

template<typename Generator, typename std::enable_if< ! std::is_convertible< Generator, const_reference >::value >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR	small_vector (size_type count, Generator g, const allocator_type &alloc=allocator_type())

PLUMED_GCH_CPP20_CONSTEXPR	small_vector (small_vector &&other) noexcept(std::is_nothrow_move_constructible< value_type >::value\|\|InlineCapacity==0)

PLUMED_GCH_CPP20_CONSTEXPR	small_vector (small_vector &&other, const allocator_type &alloc)

template<unsigned I>
PLUMED_GCH_CPP20_CONSTEXPR	small_vector (small_vector< T, I, Allocator > &&other) noexcept(std::is_nothrow_move_constructible< value_type >::value &&I< InlineCapacity)

template<unsigned I>
PLUMED_GCH_CPP20_CONSTEXPR	small_vector (small_vector< T, I, Allocator > &&other, const allocator_type &alloc)

PLUMED_GCH_CPP20_CONSTEXPR	small_vector (std::initializer_list< value_type > init, const allocator_type &alloc=allocator_type())

PLUMED_GCH_CPP20_CONSTEXPR	small_vector (void) noexcept(noexcept(allocator_type()))=default

PLUMED_GCH_CPP20_CONSTEXPR	~small_vector (void)=default

template<unsigned I>
PLUMED_GCH_CPP20_CONSTEXPR small_vector &	append (const small_vector< T, I, Allocator > &other)

template<typename InputIt, typename std::enable_if< std::is_base_of< std::input_iterator_tag, typename std::iterator_traits< InputIt >::iterator_category >::value >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR small_vector &	append (InputIt first, InputIt last)

template<unsigned I>
PLUMED_GCH_CPP20_CONSTEXPR small_vector &	append (small_vector< T, I, Allocator > &&other)

PLUMED_GCH_CPP20_CONSTEXPR small_vector &	append (std::initializer_list< value_type > ilist)

PLUMED_GCH_CPP20_CONSTEXPR void	assign (const small_vector &other)

template<unsigned I>
PLUMED_GCH_CPP20_CONSTEXPR void	assign (const small_vector< T, I, Allocator > &other)

template<typename InputIt, typename std::enable_if< std::is_base_of< std::input_iterator_tag, typename std::iterator_traits< InputIt >::iterator_category >::value >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR void	assign (InputIt first, InputIt last)

PLUMED_GCH_CPP20_CONSTEXPR void	assign (size_type count, const_reference value)

PLUMED_GCH_CPP20_CONSTEXPR void	assign (small_vector &&other) noexcept((std::is_same< std::allocator< value_type >, Allocator >::value\|\|std::allocator_traits< Allocator >::propagate_on_container_move_assignment::value) &&((std::is_nothrow_move_assignable< value_type >::value &&std::is_nothrow_move_constructible< value_type >::value)\|\|InlineCapacity==0))

template<unsigned I>
PLUMED_GCH_CPP20_CONSTEXPR void	assign (small_vector< T, I, Allocator > &&other) noexcept(I<=InlineCapacity &&(std::is_same< std::allocator< value_type >, Allocator >::value\|\|std::allocator_traits< Allocator >::propagate_on_container_move_assignment::value) &&std::is_nothrow_move_assignable< value_type >::value &&std::is_nothrow_move_constructible< value_type >::value)

PLUMED_GCH_CPP20_CONSTEXPR void	assign (std::initializer_list< value_type > ilist)

PLUMED_GCH_CPP14_CONSTEXPR reference	at (size_type pos)

PLUMED_GCH_CPP14_CONSTEXPR const_reference	at (size_type pos) const

PLUMED_GCH_CPP14_CONSTEXPR reference	back (void)

constexpr const_reference	back (void) const

constexpr const_iterator	begin (void) const noexcept

PLUMED_GCH_CPP14_CONSTEXPR iterator	begin (void) noexcept

constexpr size_type	capacity (void) const noexcept

constexpr const_iterator	cbegin (void) const noexcept

constexpr const_iterator	cend (void) const noexcept

PLUMED_GCH_CPP20_CONSTEXPR void	clear (void) noexcept

constexpr const_reverse_iterator	crbegin (void) const noexcept

constexpr const_reverse_iterator	crend (void) const noexcept

constexpr const_pointer	data (void) const noexcept

PLUMED_GCH_CPP14_CONSTEXPR pointer	data (void) noexcept

template<typename ... Args>
PLUMED_GCH_CPP20_CONSTEXPR iterator	emplace (const_iterator pos, Args &&... args)

template<typename ... Args>
PLUMED_GCH_CPP20_CONSTEXPR reference	emplace_back (Args &&... args)

PLUMED_GCH_NODISCARD constexpr bool	empty (void) const noexcept

constexpr const_iterator	end (void) const noexcept

PLUMED_GCH_CPP14_CONSTEXPR iterator	end (void) noexcept

PLUMED_GCH_CPP20_CONSTEXPR iterator	erase (const_iterator first, const_iterator last)

PLUMED_GCH_CPP20_CONSTEXPR iterator	erase (const_iterator pos)

PLUMED_GCH_CPP14_CONSTEXPR reference	front (void)

constexpr const_reference	front (void) const

constexpr allocator_type	get_allocator (void) const noexcept

PLUMED_GCH_NODISCARD constexpr bool	inlinable (void) const noexcept

PLUMED_GCH_NODISCARD constexpr bool	inlined (void) const noexcept

PLUMED_GCH_CPP20_CONSTEXPR iterator	insert (const_iterator pos, const_reference value)

template<typename InputIt, typename std::enable_if< std::is_base_of< std::input_iterator_tag, typename std::iterator_traits< InputIt >::iterator_category >::value >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR iterator	insert (const_iterator pos, InputIt first, InputIt last)

PLUMED_GCH_CPP20_CONSTEXPR iterator	insert (const_iterator pos, size_type count, const_reference value)

PLUMED_GCH_CPP20_CONSTEXPR iterator	insert (const_iterator pos, std::initializer_list< value_type > ilist)

PLUMED_GCH_CPP20_CONSTEXPR iterator	insert (const_iterator pos, value_type &&value)

PLUMED_GCH_CPP14_CONSTEXPR size_type	max_size (void) const noexcept

PLUMED_GCH_CPP20_CONSTEXPR small_vector &	operator= (const small_vector &other)

PLUMED_GCH_CPP20_CONSTEXPR small_vector &	operator= (small_vector &&other) noexcept((std::is_same< std::allocator< value_type >, Allocator >::value\|\|std::allocator_traits< Allocator >::propagate_on_container_move_assignment::value) &&((std::is_nothrow_move_assignable< value_type >::value &&std::is_nothrow_move_constructible< value_type >::value)\|\|InlineCapacity==0))

PLUMED_GCH_CPP20_CONSTEXPR small_vector &	operator= (std::initializer_list< value_type > ilist)

PLUMED_GCH_CPP14_CONSTEXPR reference	operator[] (size_type pos)

constexpr const_reference	operator[] (size_type pos) const

PLUMED_GCH_CPP20_CONSTEXPR void	pop_back (void)

PLUMED_GCH_CPP20_CONSTEXPR void	push_back (const_reference value)

PLUMED_GCH_CPP20_CONSTEXPR void	push_back (value_type &&value)

constexpr const_reverse_iterator	rbegin (void) const noexcept

PLUMED_GCH_CPP14_CONSTEXPR reverse_iterator	rbegin (void) noexcept

constexpr const_reverse_iterator	rend (void) const noexcept

PLUMED_GCH_CPP14_CONSTEXPR reverse_iterator	rend (void) noexcept

PLUMED_GCH_CPP20_CONSTEXPR void	reserve (size_type new_capacity)

PLUMED_GCH_CPP20_CONSTEXPR void	resize (size_type count)

PLUMED_GCH_CPP20_CONSTEXPR void	resize (size_type count, const_reference value)

PLUMED_GCH_CPP20_CONSTEXPR void	shrink_to_fit (void)

constexpr size_type	size (void) const noexcept

template<typename ValueType = value_type, typename std::enable_if<(std::is_move_constructible< ValueType >::value &&std::is_move_assignable< ValueType >::value)\|\|((std::is_same< std::allocator< value_type >, Allocator >::value\|\|std::allocator_traits< Allocator >::propagate_on_container_swap::value) &&InlineCapacity==0) >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR void	swap (small_vector &other) noexcept((std::is_same< std::allocator< value_type >, Allocator >::value\|\|std::allocator_traits< Allocator >::propagate_on_container_swap::value) &&((std::is_nothrow_move_constructible< value_type >::value &&std::is_nothrow_move_assignable< value_type >::value &&detail::small_vector_adl::is_nothrow_swappable< value_type >::value)\|\|InlineCapacity==0))

Static Public Member Functions
static PLUMED_GCH_NODISCARD PLUMED_GCH_CONSTEVAL size_type	inline_capacity (void) noexcept

Static Public Attributes
static constexpr unsigned	inline_capacity_v = InlineCapacity

Private Types
using	alloc_base = allocator_inliner<Allocator>

using	alloc_interface = allocator_interface<Allocator>

using	alloc_traits = typename alloc_interface::alloc_traits

using	alloc_ty = Allocator

using	base = detail::small_vector_base<Allocator, InlineCapacity>

template<bool B>
using	bool_constant = std::integral_constant<bool, B>

using	cptr = typename alloc_interface::cptr

using	cvptr = typename alloc_traits::const_void_pointer

using	diff_ty = typename alloc_interface::diff_ty

template<typename T>
using	is_complete = typename alloc_interface::template is_complete<T>

template<typename ... Args>
using	is_memcpyable = typename alloc_interface::template is_memcpyable<Args...>

template<typename ... Args>
using	is_memcpyable_iterator

using	ptr = typename alloc_interface::ptr

using	size_ty = typename alloc_interface::size_ty

template<typename T>
using	underlying_if_enum_t = typename underlying_if_enum<T>::type

using	value_ty = typename alloc_interface::value_ty

template<typename ...>
using	void_t = void

using	vptr = typename alloc_traits::void_pointer

Private Member Functions
PLUMED_GCH_NODISCARD PLUMED_GCH_CPP20_CONSTEXPR ptr	allocate (size_ty n)

PLUMED_GCH_NODISCARD PLUMED_GCH_CPP20_CONSTEXPR ptr	allocate_with_hint (size_ty n, cptr hint)

PLUMED_GCH_NODISCARD constexpr cptr	allocation_end_ptr (void) const noexcept

PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR ptr	allocation_end_ptr (void) noexcept

PLUMED_GCH_CPP20_CONSTEXPR ptr	append_copies (size_ty count, const value_ty &val)

template<typename ... Args>
PLUMED_GCH_CPP20_CONSTEXPR ptr	append_element (Args &&... args)

template<typename MovePolicy = void, typename ForwardIt>
PLUMED_GCH_CPP20_CONSTEXPR ptr	append_range (ForwardIt first, ForwardIt last, std::forward_iterator_tag)

template<typename MovePolicy, typename InputIt, typename std::enable_if< std::is_same< MovePolicy, strong_exception_policy >::value, bool >::type = true>
PLUMED_GCH_CPP20_CONSTEXPR ptr	append_range (InputIt first, InputIt last, std::input_iterator_tag)

template<typename MovePolicy = void, typename InputIt, typename std::enable_if< ! std::is_same< MovePolicy, strong_exception_policy >::value, bool >::type = false>
PLUMED_GCH_CPP20_CONSTEXPR ptr	append_range (InputIt first, InputIt last, std::input_iterator_tag)

PLUMED_GCH_CPP20_CONSTEXPR void	assign_with_copies (size_ty count, const value_ty &val)

template<typename ForwardIt, typename std::enable_if< std::is_assignable< value_ty &, decltype(std::declval< ForwardIt >())>::value, ::type = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR void	assign_with_range (ForwardIt first, ForwardIt last, std::forward_iterator_tag)

template<typename InputIt, typename std::enable_if< std::is_assignable< value_ty &, decltype(std::declval< InputIt >())>::value, ::type = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR void	assign_with_range (InputIt first, InputIt last, std::input_iterator_tag)

template<typename InputIt, typename std::enable_if<! std::is_assignable< value_ty &, decltype(std::declval< InputIt >())>::value, ::type = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR void	assign_with_range (InputIt first, InputIt last, std::input_iterator_tag)

PLUMED_GCH_NODISCARD constexpr cptr	begin_ptr (void) const noexcept

PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR ptr	begin_ptr (void) noexcept

PLUMED_GCH_CPP20_CONSTEXPR ptr	checked_allocate (size_ty n)

PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR size_ty	checked_calculate_new_capacity (const size_ty minimum_required_capacity) const

template<typename A = alloc_ty, typename V = value_ty, typename ... Args, typename std::enable_if<(sizeof...(Args) !=1\|\|! is_uninitialized_memcpyable< V, Args... >::value) &&has_alloc_construct< A, V, Args... >::value >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR void	construct (ptr p, Args &&... args) noexcept(noexcept(alloc_traits::construct(std::declval< alloc_ty & >(), std::declval< value_ty * >(), std::forward< Args >(args)...)))

template<typename U, typename std::enable_if< is_uninitialized_memcpyable< value_ty, U >::value >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR void	construct (ptr p, U &&val) noexcept

PLUMED_GCH_NODISCARD constexpr alloc_ty	copy_allocator (void) const noexcept

template<unsigned I, typename AT = alloc_traits, typename std::enable_if< AT::propagate_on_container_copy_assignment::value >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR small_vector_base &	copy_assign (const small_vector_base< Allocator, I > &other)

template<unsigned I, typename AT = alloc_traits, typename std::enable_if<! AT::propagate_on_container_copy_assignment::value >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR small_vector_base &	copy_assign (const small_vector_base< Allocator, I > &other)

template<unsigned I>
PLUMED_GCH_CPP20_CONSTEXPR small_vector_base &	copy_assign_default (const small_vector_base< Allocator, I > &other)

template<typename InputIt, typename std::enable_if< ! is_memcpyable_iterator< InputIt >::value &&! std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< InputIt >::iterator_category >::value >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR InputIt	copy_n_return_in (InputIt first, size_ty count, ptr dest)

template<typename InputIt, typename std::enable_if< is_memcpyable_iterator< InputIt >::value >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR InputIt	copy_n_return_in (InputIt first, size_ty count, ptr dest) noexcept

template<typename RandomIt, typename std::enable_if< ! is_memcpyable_iterator< RandomIt >::value &&std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< RandomIt >::iterator_category >::value >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR RandomIt	copy_n_return_in (RandomIt first, size_ty count, ptr dest)

template<typename InputIt, typename std::enable_if< is_memcpyable_iterator< InputIt >::value >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR std::move_iterator< InputIt >	copy_n_return_in (std::move_iterator< InputIt > first, size_ty count, ptr dest) noexcept

template<typename InputIt>
PLUMED_GCH_CPP20_CONSTEXPR ptr	copy_range (InputIt first, InputIt last, ptr dest)

PLUMED_GCH_NODISCARD constexpr cptr	data_ptr (void) const noexcept

PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR ptr	data_ptr (void) noexcept

PLUMED_GCH_CPP20_CONSTEXPR void	deallocate (ptr p, size_ty n)

PLUMED_GCH_CPP20_CONSTEXPR void	decrease_size (size_ty n) noexcept

template<typename InputIt>
PLUMED_GCH_CPP20_CONSTEXPR ptr	default_uninitialized_copy (InputIt first, InputIt last, ptr d_first)

PLUMED_GCH_CPP20_CONSTEXPR ptr	default_uninitialized_value_construct (ptr first, ptr last)

template<typename A = alloc_ty, typename V = value_ty, typename std::enable_if<(! is_trivially_destructible< V >::value\|\|must_use_alloc_destroy< A, V >::value) &&has_alloc_destroy< A, V >::value >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR void	destroy (ptr p) noexcept

template<typename A = alloc_ty, typename V = value_ty, typename std::enable_if< is_trivially_destructible< V >::value &&! must_use_alloc_destroy< A, V >::value >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR void	destroy (ptr) const noexcept

template<typename A = alloc_ty, typename V = value_ty, typename std::enable_if<! is_trivially_destructible< V >::value\|\|must_use_alloc_destroy< A, V >::value >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR void	destroy_range (ptr first, ptr last) noexcept

template<typename A = alloc_ty, typename V = value_ty, typename std::enable_if< is_trivially_destructible< V >::value &&! must_use_alloc_destroy< A, V >::value >::type * = nullptr>
PLUMED_GCH_CPP14_CONSTEXPR void	destroy_range (ptr, ptr) const noexcept

template<typename ... Args>
PLUMED_GCH_CPP20_CONSTEXPR ptr	emplace_at (ptr pos, Args &&... args)

template<typename ... Args>
PLUMED_GCH_CPP20_CONSTEXPR ptr	emplace_into_current (ptr pos, Args &&... args)

template<typename V = value_ty, typename std::enable_if< std::is_nothrow_move_constructible< V >::value >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR ptr	emplace_into_current (ptr pos, value_ty &&val)

template<typename ... Args>
PLUMED_GCH_CPP20_CONSTEXPR ptr	emplace_into_current_end (Args &&... args)

template<typename ... Args>
PLUMED_GCH_CPP20_CONSTEXPR ptr	emplace_into_reallocation (ptr pos, Args &&... args)

template<typename ... Args>
PLUMED_GCH_CPP20_CONSTEXPR ptr	emplace_into_reallocation_end (Args &&... args)

PLUMED_GCH_NODISCARD constexpr cptr	end_ptr (void) const noexcept

PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR ptr	end_ptr (void) noexcept

PLUMED_GCH_CPP20_CONSTEXPR void	erase_all (void)

PLUMED_GCH_CPP20_CONSTEXPR ptr	erase_at (ptr pos)

PLUMED_GCH_CPP20_CONSTEXPR void	erase_last (void)

PLUMED_GCH_CPP20_CONSTEXPR ptr	erase_range (ptr first, ptr last)

PLUMED_GCH_CPP20_CONSTEXPR void	erase_to_end (ptr pos)

PLUMED_GCH_NODISCARD constexpr size_ty	get_capacity (void) const noexcept

PLUMED_GCH_NODISCARD PLUMED_GCH_CPP20_CONSTEXPR size_ty	get_max_size (void) const noexcept

PLUMED_GCH_NODISCARD constexpr size_ty	get_size (void) const noexcept

PLUMED_GCH_NODISCARD constexpr bool	has_allocation (void) const noexcept

PLUMED_GCH_CPP20_CONSTEXPR void	increase_size (size_ty n) noexcept

PLUMED_GCH_CPP20_CONSTEXPR ptr	insert_copies (ptr pos, size_ty count, const value_ty &val)

template<typename ForwardIt>
PLUMED_GCH_CPP20_CONSTEXPR ptr	insert_range (ptr pos, ForwardIt first, ForwardIt last, std::forward_iterator_tag)

template<typename InputIt>
PLUMED_GCH_CPP20_CONSTEXPR ptr	insert_range (ptr pos, InputIt first, InputIt last, std::input_iterator_tag)

template<typename ForwardIt>
PLUMED_GCH_CPP20_CONSTEXPR ptr	insert_range_helper (ptr pos, ForwardIt first, ForwardIt last)

PLUMED_GCH_NODISCARD constexpr bool	is_inlinable (void) const noexcept

template<unsigned I>
PLUMED_GCH_CPP20_CONSTEXPR void	move_allocation_pointer (small_vector_base< alloc_ty, I > &&other) noexcept

template<unsigned I, typename A = alloc_ty, typename std::enable_if<! allocations_are_movable< A >::value >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR small_vector_base &	move_assign (small_vector_base< Allocator, I > &&other)

template<unsigned I, typename A = alloc_ty, typename std::enable_if< allocations_are_movable< A >::value >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR small_vector_base &	move_assign (small_vector_base< Allocator, I > &&other) noexcept(noexcept(std::declval< small_vector_base & >().move_assign_default(std::move(other))))

template<unsigned N = InlineCapacity, typename std::enable_if< N==0 >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR small_vector_base &	move_assign_default (small_vector_base &&other) noexcept

template<unsigned GreaterI, typename std::enable_if<(InlineCapacity< GreaterI)>::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR small_vector_base &	move_assign_default (small_vector_base< Allocator, GreaterI > &&other)

template<unsigned LessEqualI, typename std::enable_if<(LessEqualI<=InlineCapacity)>::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR small_vector_base &	move_assign_default (small_vector_base< Allocator, LessEqualI > &&other) noexcept(std::is_nothrow_move_assignable< value_ty >::value &&std::is_nothrow_move_constructible< value_ty >::value)

template<unsigned I>
PLUMED_GCH_CPP20_CONSTEXPR small_vector_base &	move_assign_unequal_no_propagate (small_vector_base< Allocator, I > &&other)

template<unsigned I = InlineCapacity, typename std::enable_if< I==0 >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR void	move_initialize (small_vector_base &&other) noexcept

template<unsigned GreaterI, typename std::enable_if<(InlineCapacity< GreaterI)>::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR void	move_initialize (small_vector_base< Allocator, GreaterI > &&other)

template<unsigned LessEqualI, typename std::enable_if<(LessEqualI<=InlineCapacity)>::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR void	move_initialize (small_vector_base< Allocator, LessEqualI > &&other) noexcept(std::is_nothrow_move_constructible< value_ty >::value)

template<typename V = value_ty, typename std::enable_if< is_memcpyable< V >::value >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR ptr	move_left (ptr first, ptr last, ptr d_first)

template<typename V = value_ty, typename std::enable_if<! is_memcpyable< V >::value >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR ptr	move_left (ptr first, ptr last, ptr d_first)

template<typename V = value_ty, typename std::enable_if< is_memcpyable< V >::value, bool >::type = true>
PLUMED_GCH_CPP20_CONSTEXPR ptr	move_right (ptr first, ptr last, ptr d_last)

template<typename V = value_ty, typename std::enable_if<! is_memcpyable< V >::value, bool >::type = false>
PLUMED_GCH_CPP20_CONSTEXPR ptr	move_right (ptr first, ptr last, ptr d_last)

PLUMED_GCH_NODISCARD constexpr size_ty	num_uninitialized (void) const noexcept

PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR ptr	ptr_cast (const small_vector_iterator< cptr, diff_ty > &it) noexcept

PLUMED_GCH_CPP20_CONSTEXPR void	request_capacity (size_ty request)

PLUMED_GCH_CPP20_CONSTEXPR void	reset_data (ptr data_ptr, size_ty capacity, size_ty size)

template<typename ... ValueT>
PLUMED_GCH_CPP20_CONSTEXPR void	resize_with (size_ty new_size, const ValueT &... val)

PLUMED_GCH_CPP20_CONSTEXPR void	set_capacity (size_ty capacity) noexcept

PLUMED_GCH_CPP20_CONSTEXPR void	set_data (ptr data_ptr, size_ty capacity, size_ty size) noexcept

PLUMED_GCH_CPP20_CONSTEXPR void	set_data_ptr (ptr data_ptr) noexcept

PLUMED_GCH_CPP20_CONSTEXPR void	set_default (void)

PLUMED_GCH_CPP20_CONSTEXPR void	set_size (size_ty size) noexcept

PLUMED_GCH_CPP20_CONSTEXPR void	set_to_inline_storage (void)

PLUMED_GCH_CPP20_CONSTEXPR ptr	shift_into_uninitialized (ptr pos, size_ty n_shift)

PLUMED_GCH_CPP20_CONSTEXPR ptr	shrink_to_size (void)

PLUMED_GCH_NODISCARD constexpr cptr	storage_ptr (void) const noexcept

PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR ptr	storage_ptr (void) noexcept

template<typename A = alloc_ty, typename std::enable_if< allocations_are_swappable< A >::value &&InlineCapacity==0 >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR void	swap (small_vector_base &other) noexcept

PLUMED_GCH_CPP20_CONSTEXPR void	swap_allocation (small_vector_base &other) noexcept

PLUMED_GCH_CPP20_CONSTEXPR void	swap_capacity (small_vector_base &other) noexcept

PLUMED_GCH_CPP20_CONSTEXPR void	swap_data_ptr (small_vector_base &other) noexcept

PLUMED_GCH_CPP20_CONSTEXPR void	swap_default (small_vector_base &other) noexcept(std::is_nothrow_move_constructible< value_ty >::value &&detail::small_vector_adl::is_nothrow_swappable< value_ty >::value)

PLUMED_GCH_CPP20_CONSTEXPR void	swap_elements (small_vector_base &other) noexcept(std::is_nothrow_move_constructible< value_ty >::value &&detail::small_vector_adl::is_nothrow_swappable< value_ty >::value)

PLUMED_GCH_CPP20_CONSTEXPR void	swap_size (small_vector_base &other) noexcept

PLUMED_GCH_CPP20_CONSTEXPR void	swap_unequal_no_propagate (small_vector_base &other)

PLUMED_GCH_CPP20_CONSTEXPR ptr	unchecked_allocate (size_ty n)

PLUMED_GCH_CPP20_CONSTEXPR ptr	unchecked_allocate (size_ty n, cptr hint)

PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR size_ty	unchecked_calculate_new_capacity (const size_ty minimum_required_capacity) const noexcept

template<typename ForwardIt, typename std::enable_if< is_uninitialized_memcpyable_iterator< ForwardIt >::value, bool >::type = true>
PLUMED_GCH_CPP20_CONSTEXPR ptr	uninitialized_copy (ForwardIt first, ForwardIt last, ptr dest) noexcept

template<typename InputIt, typename std::enable_if< ! is_uninitialized_memcpyable_iterator< InputIt >::value, bool >::type = false>
PLUMED_GCH_CPP20_CONSTEXPR ptr	uninitialized_copy (InputIt first, InputIt last, ptr d_first)

template<typename ForwardIt, typename std::enable_if< is_uninitialized_memcpyable_iterator< ForwardIt >::value, bool >::type = true>
PLUMED_GCH_CPP20_CONSTEXPR ptr	uninitialized_copy (std::move_iterator< ForwardIt > first, std::move_iterator< ForwardIt > last, ptr dest) noexcept

PLUMED_GCH_CPP20_CONSTEXPR ptr	uninitialized_fill (ptr first, ptr last)

PLUMED_GCH_CPP20_CONSTEXPR ptr	uninitialized_fill (ptr first, ptr last, const value_ty &val)

template<typename Policy = void, typename V = value_ty, typename std::enable_if<! is_explicitly_move_insertable< V >::value\|\|(std::is_same< Policy, strong_exception_policy >::value &&! relocate_with_move< V >::value), bool >::type = false>
PLUMED_GCH_CPP20_CONSTEXPR ptr	uninitialized_move (ptr first, ptr last, ptr d_first) noexcept(alloc_interface::template is_uninitialized_memcpyable_iterator< ptr >::value)

template<typename Policy = void, typename V = value_ty, typename std::enable_if< is_explicitly_move_insertable< V >::value &&(! std::is_same< Policy, strong_exception_policy >::value\|\|relocate_with_move< V >::value), bool >::type = true>
PLUMED_GCH_CPP20_CONSTEXPR ptr	uninitialized_move (ptr first, ptr last, ptr d_first) noexcept(std::is_nothrow_move_constructible< value_ty >::value)

template<typename A = alloc_ty, typename V = value_ty, typename std::enable_if< is_trivially_constructible< V >::value &&! must_use_alloc_construct< A, V >::value >::type * = nullptr>
PLUMED_GCH_CPP20_CONSTEXPR ptr	uninitialized_value_construct (ptr first, ptr last)

PLUMED_GCH_CPP20_CONSTEXPR void	wipe (void)

Static Private Member Functions
template<typename V = value_ty, typename ... Args>
static PLUMED_GCH_CPP20_CONSTEXPR auto	construct_at (value_ty p, Args &&... args) noexcept(noexcept(::new(std::declval< void >()) V(std::declval< Args >()...))) -> decltype(::new(std::declval< void * >()) V(std::declval< Args >()...))

template<typename V = value_ty, typename std::enable_if< std::is_array< V >::value, bool >::type = true>
static PLUMED_GCH_CPP20_CONSTEXPR void	destroy_at (value_ty *p) noexcept

template<typename V = value_ty, typename std::enable_if<! std::is_array< V >::value, bool >::type = false>
static PLUMED_GCH_CPP20_CONSTEXPR void	destroy_at (value_ty *p) noexcept

template<typename ForwardIt, typename ItDiffT = typename std::iterator_traits<ForwardIt>::difference_type, typename std::enable_if<(numeric_max< size_ty >()< numeric_max< ItDiffT >()), bool >::type = true>
static PLUMED_GCH_NODISCARD PLUMED_GCH_CPP17_CONSTEXPR size_ty	external_range_length (ForwardIt first, ForwardIt last)

template<typename ForwardIt>
static PLUMED_GCH_NODISCARD PLUMED_GCH_CPP17_CONSTEXPR size_ty	external_range_length_impl (ForwardIt first, ForwardIt last, std::forward_iterator_tag)

template<typename RandomIt>
static PLUMED_GCH_NODISCARD PLUMED_GCH_CPP17_CONSTEXPR size_ty	external_range_length_impl (RandomIt first, RandomIt last, std::random_access_iterator_tag)

static PLUMED_GCH_NODISCARD PLUMED_GCH_CONSTEVAL size_ty	get_inline_capacity (void) noexcept

static PLUMED_GCH_NODISCARD PLUMED_GCH_CPP17_CONSTEXPR size_ty	internal_range_length (cptr first, cptr last) noexcept

template<typename Integer>
static PLUMED_GCH_NODISCARD PLUMED_GCH_CONSTEVAL std::size_t	numeric_max (void) noexcept

static PLUMED_GCH_NORETURN PLUMED_GCH_CPP20_CONSTEXPR void	throw_allocation_size_error (void)

static PLUMED_GCH_NORETURN PLUMED_GCH_CPP20_CONSTEXPR void	throw_increment_error (void)

static PLUMED_GCH_NORETURN PLUMED_GCH_CPP20_CONSTEXPR void	throw_index_error (void)

static PLUMED_GCH_NORETURN PLUMED_GCH_CPP20_CONSTEXPR void	throw_overflow_error (void)

static PLUMED_GCH_NORETURN PLUMED_GCH_CPP20_CONSTEXPR void	throw_range_length_error (void)

template<typename Pointer, typename std::enable_if< has_ptr_traits_to_address< Pointer >::value >::type * = nullptr>
static constexpr auto	to_address (const Pointer &p) noexcept -> decltype(std::pointer_traits< Pointer >::to_address(p))

static constexpr const value_ty *	to_address (const value_ty *p) noexcept

static constexpr value_ty *	to_address (value_ty *p) noexcept

template<typename Iterator, typename IteratorDiffT = typename std::iterator_traits<Iterator>::difference_type, typename Integer = IteratorDiffT>
static PLUMED_GCH_CPP17_CONSTEXPR void	unchecked_advance (Iterator &pos, Integer n) noexcept

template<typename Iterator, typename IteratorDiffT = typename std::iterator_traits<Iterator>::difference_type, typename Integer = IteratorDiffT>
static PLUMED_GCH_NODISCARD PLUMED_GCH_CPP17_CONSTEXPR Iterator	unchecked_next (Iterator pos, Integer n=1) noexcept

template<typename Iterator, typename IteratorDiffT = typename std::iterator_traits<Iterator>::difference_type, typename Integer = IteratorDiffT>
static PLUMED_GCH_NODISCARD PLUMED_GCH_CPP17_CONSTEXPR Iterator	unchecked_prev (Iterator pos, Integer n=1) noexcept

Private Attributes
small_vector_data< ptr, size_type, value_ty, InlineCapacity >	m_data

Static Private Attributes
static constexpr struct PLMD::gch::detail::small_vector_base::bypass_tag	bypass

Friends
template<typename SameT, unsigned DifferentInlineCapacity, typename SameAllocator>
class	small_vector

Member Typedef Documentation

◆ alloc_base

template<typename Allocator>

using PLMD::gch::detail::allocator_interface< Allocator >::alloc_base = allocator_inliner<Allocator>

privateinherited

◆ alloc_interface

template<typename Allocator, unsigned InlineCapacity>

using PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::alloc_interface = allocator_interface<Allocator>

protectedinherited

◆ alloc_traits

template<typename Allocator, unsigned InlineCapacity>

using PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::alloc_traits = typename alloc_interface::alloc_traits

protectedinherited

◆ alloc_ty

template<typename Allocator, unsigned InlineCapacity>

using PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::alloc_ty = Allocator

protectedinherited

◆ allocator_type

template<typename T, unsigned InlineCapacity, typename Allocator>

using PLMD::gch::small_vector< T, InlineCapacity, Allocator >::allocator_type = Allocator

◆ base

template<typename T, unsigned InlineCapacity, typename Allocator>

using PLMD::gch::small_vector< T, InlineCapacity, Allocator >::base = detail::small_vector_base<Allocator, InlineCapacity>

private

◆ bool_constant

template<typename Allocator, unsigned InlineCapacity>

template<bool B>

using PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::bool_constant = std::integral_constant<bool, B>

protectedinherited

◆ const_iterator

template<typename T, unsigned InlineCapacity, typename Allocator>

using PLMD::gch::small_vector< T, InlineCapacity, Allocator >::const_iterator = small_vector_iterator<const_pointer, difference_type>

◆ const_pointer

template<typename T, unsigned InlineCapacity, typename Allocator>

using PLMD::gch::small_vector< T, InlineCapacity, Allocator >::const_pointer = typename std::allocator_traits<allocator_type>::const_pointer

◆ const_reference

template<typename T, unsigned InlineCapacity, typename Allocator>

using PLMD::gch::small_vector< T, InlineCapacity, Allocator >::const_reference = const value_type&

◆ const_reverse_iterator

template<typename T, unsigned InlineCapacity, typename Allocator>

using PLMD::gch::small_vector< T, InlineCapacity, Allocator >::const_reverse_iterator = std::reverse_iterator<const_iterator>

◆ cptr

template<typename Allocator, unsigned InlineCapacity>

using PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::cptr = typename alloc_interface::cptr

protectedinherited

◆ cvptr

template<typename Allocator>

using PLMD::gch::detail::allocator_interface< Allocator >::cvptr = typename alloc_traits::const_void_pointer

protectedinherited

◆ diff_ty

template<typename Allocator, unsigned InlineCapacity>

using PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::diff_ty = typename alloc_interface::diff_ty

protectedinherited

◆ difference_type

template<typename T, unsigned InlineCapacity, typename Allocator>

using PLMD::gch::small_vector< T, InlineCapacity, Allocator >::difference_type = typename base::difference_type

◆ is_complete

template<typename Allocator, unsigned InlineCapacity>

template<typename T>

using PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::is_complete = typename alloc_interface::template is_complete<T>

protectedinherited

◆ is_memcpyable

template<typename Allocator, unsigned InlineCapacity>

template<typename ... Args>

using PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::is_memcpyable = typename alloc_interface::template is_memcpyable<Args...>

protectedinherited

◆ is_memcpyable_iterator

template<typename Allocator, unsigned InlineCapacity>

template<typename ... Args>

using PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::is_memcpyable_iterator

protectedinherited

Initial value:

typename alloc_interface::template is_memcpyable_iterator<Args...>

PLMD::gch::detail::small_vector_base::is_memcpyable_iterator

typename alloc_interface::template is_memcpyable_iterator< Args... > is_memcpyable_iterator

Definition small_vector.h:2694

◆ iterator

template<typename T, unsigned InlineCapacity, typename Allocator>

using PLMD::gch::small_vector< T, InlineCapacity, Allocator >::iterator = small_vector_iterator<pointer, difference_type>

◆ pointer

template<typename T, unsigned InlineCapacity, typename Allocator>

using PLMD::gch::small_vector< T, InlineCapacity, Allocator >::pointer = typename std::allocator_traits<allocator_type>::pointer

◆ ptr

template<typename Allocator, unsigned InlineCapacity>

using PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::ptr = typename alloc_interface::ptr

protectedinherited

◆ reference

template<typename T, unsigned InlineCapacity, typename Allocator>

using PLMD::gch::small_vector< T, InlineCapacity, Allocator >::reference = value_type&

◆ reverse_iterator

template<typename T, unsigned InlineCapacity, typename Allocator>

using PLMD::gch::small_vector< T, InlineCapacity, Allocator >::reverse_iterator = std::reverse_iterator<iterator>

◆ size_ty

template<typename Allocator, unsigned InlineCapacity>

using PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::size_ty = typename alloc_interface::size_ty

protectedinherited

◆ size_type

template<typename T, unsigned InlineCapacity, typename Allocator>

using PLMD::gch::small_vector< T, InlineCapacity, Allocator >::size_type = typename base::size_type

◆ underlying_if_enum_t

template<typename Allocator>

template<typename T>

using PLMD::gch::detail::allocator_interface< Allocator >::underlying_if_enum_t = typename underlying_if_enum<T>::type

privateinherited

◆ value_ty

template<typename Allocator, unsigned InlineCapacity>

using PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::value_ty = typename alloc_interface::value_ty

protectedinherited

◆ value_type

template<typename T, unsigned InlineCapacity, typename Allocator>

using PLMD::gch::small_vector< T, InlineCapacity, Allocator >::value_type = T

◆ void_t

template<typename Allocator, unsigned InlineCapacity>

template<typename ...>

using PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::void_t = void

protectedinherited

◆ vptr

template<typename Allocator>

using PLMD::gch::detail::allocator_interface< Allocator >::vptr = typename alloc_traits::void_pointer

protectedinherited

Constructor & Destructor Documentation

◆ small_vector() [1/15]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR PLMD::gch::small_vector< T, InlineCapacity, Allocator >::small_vector ( void )

defaultnoexcept

◆ small_vector() [2/15]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR PLMD::gch::small_vector< T, InlineCapacity, Allocator >::small_vector ( const small_vector< T, InlineCapacity, Allocator > & other )

inline

◆ small_vector() [3/15]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR PLMD::gch::small_vector< T, InlineCapacity, Allocator >::small_vector ( small_vector< T, InlineCapacity, Allocator > && other )

inlinenoexcept

◆ small_vector() [4/15]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR PLMD::gch::small_vector< T, InlineCapacity, Allocator >::small_vector ( const allocator_type & alloc )

inlineexplicitnoexcept

◆ small_vector() [5/15]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR PLMD::gch::small_vector< T, InlineCapacity, Allocator >::small_vector	(	const small_vector< T, InlineCapacity, Allocator > &	other,
		const allocator_type &	alloc )

inline

◆ small_vector() [6/15]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR PLMD::gch::small_vector< T, InlineCapacity, Allocator >::small_vector	(	small_vector< T, InlineCapacity, Allocator > &&	other,
		const allocator_type &	alloc )

inline

◆ small_vector() [7/15]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR PLMD::gch::small_vector< T, InlineCapacity, Allocator >::small_vector	(	size_type	count,
		const allocator_type &	alloc = allocator_type () )

inlineexplicit

◆ small_vector() [8/15]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR PLMD::gch::small_vector< T, InlineCapacity, Allocator >::small_vector	(	size_type	count,
		const_reference	value,
		const allocator_type &	alloc = allocator_type () )

inline

◆ small_vector() [9/15]

template<typename T, unsigned InlineCapacity, typename Allocator>

template<typename Generator, typename std::enable_if< ! std::is_convertible< Generator, const_reference >::value >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR PLMD::gch::small_vector< T, InlineCapacity, Allocator >::small_vector	(	size_type	count,
		Generator	g,
		const allocator_type &	alloc = allocator_type () )

inline

◆ small_vector() [10/15]

template<typename T, unsigned InlineCapacity, typename Allocator>

template<typename InputIt, typename std::enable_if< std::is_base_of< std::input_iterator_tag, typename std::iterator_traits< InputIt >::iterator_category >::value >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR PLMD::gch::small_vector< T, InlineCapacity, Allocator >::small_vector	(	InputIt	first,
		InputIt	last,
		const allocator_type &	alloc = allocator_type () )

inline

◆ small_vector() [11/15]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR PLMD::gch::small_vector< T, InlineCapacity, Allocator >::small_vector	(	std::initializer_list< value_type >	init,
		const allocator_type &	alloc = allocator_type () )

inline

◆ small_vector() [12/15]

template<typename T, unsigned InlineCapacity, typename Allocator>

template<unsigned I>

PLUMED_GCH_CPP20_CONSTEXPR PLMD::gch::small_vector< T, InlineCapacity, Allocator >::small_vector ( const small_vector< T, I, Allocator > & other )

inlineexplicit

◆ small_vector() [13/15]

template<typename T, unsigned InlineCapacity, typename Allocator>

template<unsigned I>

PLUMED_GCH_CPP20_CONSTEXPR PLMD::gch::small_vector< T, InlineCapacity, Allocator >::small_vector ( small_vector< T, I, Allocator > && other )

inlineexplicitnoexcept

◆ small_vector() [14/15]

template<typename T, unsigned InlineCapacity, typename Allocator>

template<unsigned I>

PLUMED_GCH_CPP20_CONSTEXPR PLMD::gch::small_vector< T, InlineCapacity, Allocator >::small_vector	(	const small_vector< T, I, Allocator > &	other,
		const allocator_type &	alloc )

inline

◆ small_vector() [15/15]

template<typename T, unsigned InlineCapacity, typename Allocator>

template<unsigned I>

PLUMED_GCH_CPP20_CONSTEXPR PLMD::gch::small_vector< T, InlineCapacity, Allocator >::small_vector	(	small_vector< T, I, Allocator > &&	other,
		const allocator_type &	alloc )

inline

◆ ~small_vector()

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR PLMD::gch::small_vector< T, InlineCapacity, Allocator >::~small_vector ( void )

default

Member Function Documentation

◆ allocate()

template<typename Allocator>

PLUMED_GCH_NODISCARD PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::allocator_interface< Allocator >::allocate ( size_ty n )

inlineinherited

◆ allocate_with_hint()

template<typename Allocator>

PLUMED_GCH_NODISCARD PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::allocator_interface< Allocator >::allocate_with_hint	(	size_ty	n,
		cptr	hint )

inlineinherited

◆ allocation_end_ptr() [1/2]

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_NODISCARD constexpr cptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::allocation_end_ptr ( void ) const

inlineconstexprnoexceptinherited

◆ allocation_end_ptr() [2/2]

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::allocation_end_ptr ( void )

inlinenoexceptinherited

◆ append() [1/4]

template<typename T, unsigned InlineCapacity, typename Allocator>

template<unsigned I>

PLUMED_GCH_CPP20_CONSTEXPR small_vector & PLMD::gch::small_vector< T, InlineCapacity, Allocator >::append ( const small_vector< T, I, Allocator > & other )

inline

◆ append() [2/4]

template<typename T, unsigned InlineCapacity, typename Allocator>

template<typename InputIt, typename std::enable_if< std::is_base_of< std::input_iterator_tag, typename std::iterator_traits< InputIt >::iterator_category >::value >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR small_vector & PLMD::gch::small_vector< T, InlineCapacity, Allocator >::append	(	InputIt	first,
		InputIt	last )

inline

◆ append() [3/4]

template<typename T, unsigned InlineCapacity, typename Allocator>

template<unsigned I>

PLUMED_GCH_CPP20_CONSTEXPR small_vector & PLMD::gch::small_vector< T, InlineCapacity, Allocator >::append ( small_vector< T, I, Allocator > && other )

inline

◆ append() [4/4]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR small_vector & PLMD::gch::small_vector< T, InlineCapacity, Allocator >::append ( std::initializer_list< value_type > ilist )

inline

◆ append_copies()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::append_copies	(	size_ty	count,
		const value_ty &	val )

inlineprotectedinherited

◆ append_element()

template<typename Allocator, unsigned InlineCapacity>

template<typename ... Args>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::append_element ( Args &&... args )

inlineprotectedinherited

◆ append_range() [1/3]

template<typename Allocator, unsigned InlineCapacity>

template<typename MovePolicy = void, typename ForwardIt>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::append_range	(	ForwardIt	first,
		ForwardIt	last,
		std::forward_iterator_tag	)

inlineprotectedinherited

◆ append_range() [2/3]

template<typename Allocator, unsigned InlineCapacity>

template<typename MovePolicy, typename InputIt, typename std::enable_if< std::is_same< MovePolicy, strong_exception_policy >::value, bool >::type = true>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::append_range	(	InputIt	first,
		InputIt	last,
		std::input_iterator_tag	)

inlineprotectedinherited

◆ append_range() [3/3]

template<typename Allocator, unsigned InlineCapacity>

template<typename MovePolicy = void, typename InputIt, typename std::enable_if< ! std::is_same< MovePolicy, strong_exception_policy >::value, bool >::type = false>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::append_range	(	InputIt	first,
		InputIt	last,
		std::input_iterator_tag	)

inlineprotectedinherited

◆ assign() [1/7]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::small_vector< T, InlineCapacity, Allocator >::assign ( const small_vector< T, InlineCapacity, Allocator > & other )

inline

◆ assign() [2/7]

template<typename T, unsigned InlineCapacity, typename Allocator>

template<unsigned I>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::small_vector< T, InlineCapacity, Allocator >::assign ( const small_vector< T, I, Allocator > & other )

inline

◆ assign() [3/7]

template<typename T, unsigned InlineCapacity, typename Allocator>

template<typename InputIt, typename std::enable_if< std::is_base_of< std::input_iterator_tag, typename std::iterator_traits< InputIt >::iterator_category >::value >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::small_vector< T, InlineCapacity, Allocator >::assign	(	InputIt	first,
		InputIt	last )

inline

◆ assign() [4/7]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::small_vector< T, InlineCapacity, Allocator >::assign	(	size_type	count,
		const_reference	value )

inline

◆ assign() [5/7]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::small_vector< T, InlineCapacity, Allocator >::assign ( small_vector< T, InlineCapacity, Allocator > && other )

inlinenoexcept

◆ assign() [6/7]

template<typename T, unsigned InlineCapacity, typename Allocator>

template<unsigned I>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::small_vector< T, InlineCapacity, Allocator >::assign ( small_vector< T, I, Allocator > && other )

inlinenoexcept

◆ assign() [7/7]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::small_vector< T, InlineCapacity, Allocator >::assign ( std::initializer_list< value_type > ilist )

inline

◆ assign_with_copies()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::assign_with_copies	(	size_ty	count,
		const value_ty &	val )

inlineprotectedinherited

◆ assign_with_range() [1/3]

template<typename Allocator, unsigned InlineCapacity>

template<typename ForwardIt, typename std::enable_if< std::is_assignable< value_ty &, decltype(*std::declval< ForwardIt >())>::value, ::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::assign_with_range	(	ForwardIt	first,
		ForwardIt	last,
		std::forward_iterator_tag	)

inlineprotectedinherited

◆ assign_with_range() [2/3]

template<typename Allocator, unsigned InlineCapacity>

template<typename InputIt, typename std::enable_if< std::is_assignable< value_ty &, decltype(*std::declval< InputIt >())>::value, ::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::assign_with_range	(	InputIt	first,
		InputIt	last,
		std::input_iterator_tag	)

inlineprotectedinherited

◆ assign_with_range() [3/3]

template<typename Allocator, unsigned InlineCapacity>

template<typename InputIt, typename std::enable_if<! std::is_assignable< value_ty &, decltype(*std::declval< InputIt >())>::value, ::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::assign_with_range	(	InputIt	first,
		InputIt	last,
		std::input_iterator_tag	)

inlineprotectedinherited

◆ at() [1/2]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP14_CONSTEXPR reference PLMD::gch::small_vector< T, InlineCapacity, Allocator >::at ( size_type pos )

inline

◆ at() [2/2]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP14_CONSTEXPR const_reference PLMD::gch::small_vector< T, InlineCapacity, Allocator >::at ( size_type pos ) const

inline

◆ back() [1/2]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP14_CONSTEXPR reference PLMD::gch::small_vector< T, InlineCapacity, Allocator >::back ( void )

inline

◆ back() [2/2]

template<typename T, unsigned InlineCapacity, typename Allocator>

const_reference PLMD::gch::small_vector< T, InlineCapacity, Allocator >::back ( void ) const

inlineconstexpr

◆ begin() [1/2]

template<typename T, unsigned InlineCapacity, typename Allocator>

const_iterator PLMD::gch::small_vector< T, InlineCapacity, Allocator >::begin ( void ) const

inlineconstexprnoexcept

◆ begin() [2/2]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP14_CONSTEXPR iterator PLMD::gch::small_vector< T, InlineCapacity, Allocator >::begin ( void )

inlinenoexcept

◆ begin_ptr() [1/2]

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_NODISCARD constexpr cptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::begin_ptr ( void ) const

inlineconstexprnoexceptinherited

◆ begin_ptr() [2/2]

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::begin_ptr ( void )

inlinenoexceptinherited

◆ capacity()

template<typename T, unsigned InlineCapacity, typename Allocator>

size_type PLMD::gch::small_vector< T, InlineCapacity, Allocator >::capacity ( void ) const

inlineconstexprnoexcept

◆ cbegin()

template<typename T, unsigned InlineCapacity, typename Allocator>

const_iterator PLMD::gch::small_vector< T, InlineCapacity, Allocator >::cbegin ( void ) const

inlineconstexprnoexcept

◆ cend()

template<typename T, unsigned InlineCapacity, typename Allocator>

const_iterator PLMD::gch::small_vector< T, InlineCapacity, Allocator >::cend ( void ) const

inlineconstexprnoexcept

◆ checked_allocate()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::checked_allocate ( size_ty n )

inlineprivateinherited

◆ checked_calculate_new_capacity()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR size_ty PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::checked_calculate_new_capacity ( const size_ty minimum_required_capacity ) const

inlineprotectedinherited

◆ clear()

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::small_vector< T, InlineCapacity, Allocator >::clear ( void )

inlinenoexcept

◆ construct() [1/2]

template<typename Allocator, unsigned InlineCapacity>

template<typename A = alloc_ty, typename V = value_ty, typename ... Args, typename std::enable_if<(sizeof...(Args) !=1||! is_uninitialized_memcpyable< V, Args... >::value) &&has_alloc_construct< A, V, Args... >::value >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::allocator_interface< Allocator >::construct	(	ptr	p,
		Args &&...	args )

inlineprotectednoexceptinherited

◆ construct() [2/2]

template<typename Allocator, unsigned InlineCapacity>

template<typename U, typename std::enable_if< is_uninitialized_memcpyable< value_ty, U >::value >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::allocator_interface< Allocator >::construct	(	ptr	p,
		U &&	val )

inlineprotectednoexceptinherited

◆ construct_at()

template<typename Allocator>

template<typename V = value_ty, typename ... Args>

static PLUMED_GCH_CPP20_CONSTEXPR auto PLMD::gch::detail::allocator_interface< Allocator >::construct_at	(	value_ty *	p,
		Args &&...	args ) -> decltype (::new (std::declval<void *> ()) V (std::declval<Args> ()...))

inlinestaticprivatenoexceptinherited

◆ copy_allocator()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_NODISCARD constexpr alloc_ty PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::copy_allocator ( void ) const

inlineconstexprnoexceptinherited

◆ copy_assign() [1/2]

template<typename Allocator, unsigned InlineCapacity>

template<unsigned I, typename AT = alloc_traits, typename std::enable_if< AT::propagate_on_container_copy_assignment::value >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR small_vector_base & PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::copy_assign ( const small_vector_base< Allocator, I > & other )

inlineprotectedinherited

◆ copy_assign() [2/2]

template<typename Allocator, unsigned InlineCapacity>

template<unsigned I, typename AT = alloc_traits, typename std::enable_if<! AT::propagate_on_container_copy_assignment::value >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR small_vector_base & PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::copy_assign ( const small_vector_base< Allocator, I > & other )

inlineprotectedinherited

◆ copy_assign_default()

template<typename Allocator, unsigned InlineCapacity>

template<unsigned I>

PLUMED_GCH_CPP20_CONSTEXPR small_vector_base & PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::copy_assign_default ( const small_vector_base< Allocator, I > & other )

inlineprotectedinherited

◆ copy_n_return_in() [1/4]

template<typename Allocator, unsigned InlineCapacity>

template<typename InputIt, typename std::enable_if< ! is_memcpyable_iterator< InputIt >::value &&! std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< InputIt >::iterator_category >::value >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR InputIt PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::copy_n_return_in	(	InputIt	first,
		size_ty	count,
		ptr	dest )

inlineprotectedinherited

◆ copy_n_return_in() [2/4]

template<typename Allocator, unsigned InlineCapacity>

template<typename InputIt, typename std::enable_if< is_memcpyable_iterator< InputIt >::value >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR InputIt PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::copy_n_return_in	(	InputIt	first,
		size_ty	count,
		ptr	dest )

inlineprotectednoexceptinherited

◆ copy_n_return_in() [3/4]

template<typename Allocator, unsigned InlineCapacity>

template<typename RandomIt, typename std::enable_if< ! is_memcpyable_iterator< RandomIt >::value &&std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< RandomIt >::iterator_category >::value >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR RandomIt PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::copy_n_return_in	(	RandomIt	first,
		size_ty	count,
		ptr	dest )

inlineprotectedinherited

◆ copy_n_return_in() [4/4]

template<typename Allocator, unsigned InlineCapacity>

template<typename InputIt, typename std::enable_if< is_memcpyable_iterator< InputIt >::value >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR std::move_iterator< InputIt > PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::copy_n_return_in	(	std::move_iterator< InputIt >	first,
		size_ty	count,
		ptr	dest )

inlineprotectednoexceptinherited

◆ copy_range()

template<typename Allocator, unsigned InlineCapacity>

template<typename InputIt>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::copy_range	(	InputIt	first,
		InputIt	last,
		ptr	dest )

inlineprotectedinherited

◆ crbegin()

template<typename T, unsigned InlineCapacity, typename Allocator>

const_reverse_iterator PLMD::gch::small_vector< T, InlineCapacity, Allocator >::crbegin ( void ) const

inlineconstexprnoexcept

◆ crend()

template<typename T, unsigned InlineCapacity, typename Allocator>

const_reverse_iterator PLMD::gch::small_vector< T, InlineCapacity, Allocator >::crend ( void ) const

inlineconstexprnoexcept

◆ data() [1/2]

template<typename T, unsigned InlineCapacity, typename Allocator>

const_pointer PLMD::gch::small_vector< T, InlineCapacity, Allocator >::data ( void ) const

inlineconstexprnoexcept

◆ data() [2/2]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP14_CONSTEXPR pointer PLMD::gch::small_vector< T, InlineCapacity, Allocator >::data ( void )

inlinenoexcept

◆ data_ptr() [1/2]

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_NODISCARD constexpr cptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::data_ptr ( void ) const

inlineconstexprnoexceptinherited

◆ data_ptr() [2/2]

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::data_ptr ( void )

inlinenoexceptinherited

◆ deallocate()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::allocator_interface< Allocator >::deallocate	(	ptr	p,
		size_ty	n )

inlineprotectedinherited

◆ decrease_size()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::decrease_size ( size_ty n )

inlineprivatenoexceptinherited

◆ default_uninitialized_copy()

template<typename Allocator>

template<typename InputIt>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::allocator_interface< Allocator >::default_uninitialized_copy	(	InputIt	first,
		InputIt	last,
		ptr	d_first )

inlineinherited

◆ default_uninitialized_value_construct()

template<typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::allocator_interface< Allocator >::default_uninitialized_value_construct	(	ptr	first,
		ptr	last )

inlineinherited

◆ destroy() [1/2]

template<typename Allocator, unsigned InlineCapacity>

template<typename A = alloc_ty, typename V = value_ty, typename std::enable_if<(! is_trivially_destructible< V >::value||must_use_alloc_destroy< A, V >::value) &&has_alloc_destroy< A, V >::value >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::allocator_interface< Allocator >::destroy ( ptr p )

inlineprotectednoexceptinherited

◆ destroy() [2/2]

template<typename Allocator, unsigned InlineCapacity>

template<typename A = alloc_ty, typename V = value_ty, typename std::enable_if< is_trivially_destructible< V >::value &&! must_use_alloc_destroy< A, V >::value >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::allocator_interface< Allocator >::destroy ( ptr ) const

inlineprotectednoexceptinherited

◆ destroy_at() [1/2]

template<typename Allocator>

template<typename V = value_ty, typename std::enable_if< std::is_array< V >::value, bool >::type = true>

static PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::allocator_interface< Allocator >::destroy_at ( value_ty * p )

inlinestaticprivatenoexceptinherited

◆ destroy_at() [2/2]

template<typename Allocator>

template<typename V = value_ty, typename std::enable_if<! std::is_array< V >::value, bool >::type = false>

static PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::allocator_interface< Allocator >::destroy_at ( value_ty * p )

inlinestaticprivatenoexceptinherited

◆ destroy_range() [1/2]

template<typename Allocator, unsigned InlineCapacity>

template<typename A = alloc_ty, typename V = value_ty, typename std::enable_if<! is_trivially_destructible< V >::value||must_use_alloc_destroy< A, V >::value >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::allocator_interface< Allocator >::destroy_range	(	ptr	first,
		ptr	last )

inlineprotectednoexceptinherited

◆ destroy_range() [2/2]

template<typename Allocator, unsigned InlineCapacity>

template<typename A = alloc_ty, typename V = value_ty, typename std::enable_if< is_trivially_destructible< V >::value &&! must_use_alloc_destroy< A, V >::value >::type * = nullptr>

PLUMED_GCH_CPP14_CONSTEXPR void PLMD::gch::detail::allocator_interface< Allocator >::destroy_range	(	ptr	,
		ptr	) const

inlineprotectednoexceptinherited

◆ emplace()

template<typename T, unsigned InlineCapacity, typename Allocator>

template<typename ... Args>

PLUMED_GCH_CPP20_CONSTEXPR iterator PLMD::gch::small_vector< T, InlineCapacity, Allocator >::emplace	(	const_iterator	pos,
		Args &&...	args )

inline

◆ emplace_at()

template<typename Allocator, unsigned InlineCapacity>

template<typename ... Args>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::emplace_at	(	ptr	pos,
		Args &&...	args )

inlineprotectedinherited

◆ emplace_back()

template<typename T, unsigned InlineCapacity, typename Allocator>

template<typename ... Args>

PLUMED_GCH_CPP20_CONSTEXPR reference PLMD::gch::small_vector< T, InlineCapacity, Allocator >::emplace_back ( Args &&... args )

inline

◆ emplace_into_current() [1/2]

template<typename Allocator, unsigned InlineCapacity>

template<typename ... Args>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::emplace_into_current	(	ptr	pos,
		Args &&...	args )

inlineprotectedinherited

◆ emplace_into_current() [2/2]

template<typename Allocator, unsigned InlineCapacity>

template<typename V = value_ty, typename std::enable_if< std::is_nothrow_move_constructible< V >::value >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::emplace_into_current	(	ptr	pos,
		value_ty &&	val )

inlineprotectedinherited

◆ emplace_into_current_end()

template<typename Allocator, unsigned InlineCapacity>

template<typename ... Args>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::emplace_into_current_end ( Args &&... args )

inlineprotectedinherited

◆ emplace_into_reallocation()

template<typename Allocator, unsigned InlineCapacity>

template<typename ... Args>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::emplace_into_reallocation	(	ptr	pos,
		Args &&...	args )

inlineprotectedinherited

◆ emplace_into_reallocation_end()

template<typename Allocator, unsigned InlineCapacity>

template<typename ... Args>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::emplace_into_reallocation_end ( Args &&... args )

inlineprotectedinherited

◆ empty()

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_NODISCARD constexpr bool PLMD::gch::small_vector< T, InlineCapacity, Allocator >::empty ( void ) const

inlineconstexprnoexcept

◆ end() [1/2]

template<typename T, unsigned InlineCapacity, typename Allocator>

const_iterator PLMD::gch::small_vector< T, InlineCapacity, Allocator >::end ( void ) const

inlineconstexprnoexcept

◆ end() [2/2]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP14_CONSTEXPR iterator PLMD::gch::small_vector< T, InlineCapacity, Allocator >::end ( void )

inlinenoexcept

◆ end_ptr() [1/2]

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_NODISCARD constexpr cptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::end_ptr ( void ) const

inlineconstexprnoexceptinherited

◆ end_ptr() [2/2]

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::end_ptr ( void )

inlinenoexceptinherited

◆ erase() [1/2]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR iterator PLMD::gch::small_vector< T, InlineCapacity, Allocator >::erase	(	const_iterator	first,
		const_iterator	last )

inline

◆ erase() [2/2]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR iterator PLMD::gch::small_vector< T, InlineCapacity, Allocator >::erase ( const_iterator pos )

inline

◆ erase_all()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::erase_all ( void )

inlineprotectedinherited

◆ erase_at()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::erase_at ( ptr pos )

inlineprotectedinherited

◆ erase_last()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::erase_last ( void )

inlineprotectedinherited

◆ erase_range()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::erase_range	(	ptr	first,
		ptr	last )

inlineprotectedinherited

◆ erase_to_end()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::erase_to_end ( ptr pos )

inlineprotectedinherited

◆ external_range_length()

template<typename Allocator, unsigned InlineCapacity>

template<typename ForwardIt, typename ItDiffT = typename std::iterator_traits<ForwardIt>::difference_type, typename std::enable_if<(numeric_max< size_ty >()< numeric_max< ItDiffT >()), bool >::type = true>

static PLUMED_GCH_NODISCARD PLUMED_GCH_CPP17_CONSTEXPR size_ty PLMD::gch::detail::allocator_interface< Allocator >::external_range_length	(	ForwardIt	first,
		ForwardIt	last )

inlinestaticprotectedinherited

◆ external_range_length_impl() [1/2]

template<typename Allocator>

template<typename ForwardIt>

static PLUMED_GCH_NODISCARD PLUMED_GCH_CPP17_CONSTEXPR size_ty PLMD::gch::detail::allocator_interface< Allocator >::external_range_length_impl	(	ForwardIt	first,
		ForwardIt	last,
		std::forward_iterator_tag	)

inlinestaticinherited

◆ external_range_length_impl() [2/2]

template<typename Allocator>

template<typename RandomIt>

static PLUMED_GCH_NODISCARD PLUMED_GCH_CPP17_CONSTEXPR size_ty PLMD::gch::detail::allocator_interface< Allocator >::external_range_length_impl	(	RandomIt	first,
		RandomIt	last,
		std::random_access_iterator_tag	)

inlinestaticinherited

◆ front() [1/2]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP14_CONSTEXPR reference PLMD::gch::small_vector< T, InlineCapacity, Allocator >::front ( void )

inline

◆ front() [2/2]

template<typename T, unsigned InlineCapacity, typename Allocator>

const_reference PLMD::gch::small_vector< T, InlineCapacity, Allocator >::front ( void ) const

inlineconstexpr

◆ get_allocator()

template<typename T, unsigned InlineCapacity, typename Allocator>

allocator_type PLMD::gch::small_vector< T, InlineCapacity, Allocator >::get_allocator ( void ) const

inlineconstexprnoexcept

◆ get_capacity()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_NODISCARD constexpr size_ty PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::get_capacity ( void ) const

inlineconstexprnoexceptinherited

◆ get_inline_capacity()

template<typename Allocator, unsigned InlineCapacity>

static PLUMED_GCH_NODISCARD PLUMED_GCH_CONSTEVAL size_ty PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::get_inline_capacity ( void )

inlinestaticprotectednoexceptinherited

◆ get_max_size()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_NODISCARD PLUMED_GCH_CPP20_CONSTEXPR size_ty PLMD::gch::detail::allocator_interface< Allocator >::get_max_size ( void ) const

inlineprotectednoexceptinherited

◆ get_size()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_NODISCARD constexpr size_ty PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::get_size ( void ) const

inlineconstexprnoexceptinherited

◆ has_allocation()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_NODISCARD constexpr bool PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::has_allocation ( void ) const

inlineconstexprnoexceptinherited

◆ increase_size()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::increase_size ( size_ty n )

inlineprivatenoexceptinherited

◆ inlinable()

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_NODISCARD constexpr bool PLMD::gch::small_vector< T, InlineCapacity, Allocator >::inlinable ( void ) const

inlineconstexprnoexcept

◆ inline_capacity()

template<typename T, unsigned InlineCapacity, typename Allocator>

static PLUMED_GCH_NODISCARD PLUMED_GCH_CONSTEVAL size_type PLMD::gch::small_vector< T, InlineCapacity, Allocator >::inline_capacity ( void )

inlinestaticnoexcept

◆ inlined()

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_NODISCARD constexpr bool PLMD::gch::small_vector< T, InlineCapacity, Allocator >::inlined ( void ) const

inlineconstexprnoexcept

◆ insert() [1/5]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR iterator PLMD::gch::small_vector< T, InlineCapacity, Allocator >::insert	(	const_iterator	pos,
		const_reference	value )

inline

◆ insert() [2/5]

template<typename T, unsigned InlineCapacity, typename Allocator>

template<typename InputIt, typename std::enable_if< std::is_base_of< std::input_iterator_tag, typename std::iterator_traits< InputIt >::iterator_category >::value >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR iterator PLMD::gch::small_vector< T, InlineCapacity, Allocator >::insert	(	const_iterator	pos,
		InputIt	first,
		InputIt	last )

inline

◆ insert() [3/5]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR iterator PLMD::gch::small_vector< T, InlineCapacity, Allocator >::insert	(	const_iterator	pos,
		size_type	count,
		const_reference	value )

inline

◆ insert() [4/5]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR iterator PLMD::gch::small_vector< T, InlineCapacity, Allocator >::insert	(	const_iterator	pos,
		std::initializer_list< value_type >	ilist )

inline

◆ insert() [5/5]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR iterator PLMD::gch::small_vector< T, InlineCapacity, Allocator >::insert	(	const_iterator	pos,
		value_type &&	value )

inline

◆ insert_copies()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::insert_copies	(	ptr	pos,
		size_ty	count,
		const value_ty &	val )

inlineprotectedinherited

◆ insert_range() [1/2]

template<typename Allocator, unsigned InlineCapacity>

template<typename ForwardIt>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::insert_range	(	ptr	pos,
		ForwardIt	first,
		ForwardIt	last,
		std::forward_iterator_tag	)

inlineprotectedinherited

◆ insert_range() [2/2]

template<typename Allocator, unsigned InlineCapacity>

template<typename InputIt>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::insert_range	(	ptr	pos,
		InputIt	first,
		InputIt	last,
		std::input_iterator_tag	)

inlineprotectedinherited

◆ insert_range_helper()

template<typename Allocator, unsigned InlineCapacity>

template<typename ForwardIt>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::insert_range_helper	(	ptr	pos,
		ForwardIt	first,
		ForwardIt	last )

inlineprotectedinherited

◆ internal_range_length()

template<typename Allocator, unsigned InlineCapacity>

static PLUMED_GCH_NODISCARD PLUMED_GCH_CPP17_CONSTEXPR size_ty PLMD::gch::detail::allocator_interface< Allocator >::internal_range_length	(	cptr	first,
		cptr	last )

inlinestaticprotectednoexceptinherited

◆ is_inlinable()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_NODISCARD constexpr bool PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::is_inlinable ( void ) const

inlineconstexprnoexceptinherited

◆ max_size()

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP14_CONSTEXPR size_type PLMD::gch::small_vector< T, InlineCapacity, Allocator >::max_size ( void ) const

inlinenoexcept

◆ move_allocation_pointer()

template<typename Allocator, unsigned InlineCapacity>

template<unsigned I>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::move_allocation_pointer ( small_vector_base< alloc_ty, I > && other )

inlineprotectednoexceptinherited

◆ move_assign() [1/2]

template<typename Allocator, unsigned InlineCapacity>

template<unsigned I, typename A = alloc_ty, typename std::enable_if<! allocations_are_movable< A >::value >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR small_vector_base & PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::move_assign ( small_vector_base< Allocator, I > && other )

inlineprotectedinherited

◆ move_assign() [2/2]

template<typename Allocator, unsigned InlineCapacity>

template<unsigned I, typename A = alloc_ty, typename std::enable_if< allocations_are_movable< A >::value >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR small_vector_base & PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::move_assign ( small_vector_base< Allocator, I > && other )

inlineprotectednoexceptinherited

◆ move_assign_default() [1/3]

template<typename Allocator, unsigned InlineCapacity>

template<unsigned N = InlineCapacity, typename std::enable_if< N==0 >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR small_vector_base & PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::move_assign_default ( small_vector_base< Allocator, InlineCapacity > && other )

inlineprotectednoexceptinherited

◆ move_assign_default() [2/3]

template<typename Allocator, unsigned InlineCapacity>

template<unsigned GreaterI, typename std::enable_if<(InlineCapacity< GreaterI)>::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR small_vector_base & PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::move_assign_default ( small_vector_base< Allocator, GreaterI > && other )

inlineprotectedinherited

◆ move_assign_default() [3/3]

template<typename Allocator, unsigned InlineCapacity>

template<unsigned LessEqualI, typename std::enable_if<(LessEqualI<=InlineCapacity)>::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR small_vector_base & PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::move_assign_default ( small_vector_base< Allocator, LessEqualI > && other )

inlineprotectednoexceptinherited

◆ move_assign_unequal_no_propagate()

template<typename Allocator, unsigned InlineCapacity>

template<unsigned I>

PLUMED_GCH_CPP20_CONSTEXPR small_vector_base & PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::move_assign_unequal_no_propagate ( small_vector_base< Allocator, I > && other )

inlineprotectedinherited

◆ move_initialize() [1/3]

template<typename Allocator, unsigned InlineCapacity>

template<unsigned I = InlineCapacity, typename std::enable_if< I==0 >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::move_initialize ( small_vector_base< Allocator, InlineCapacity > && other )

inlineprotectednoexceptinherited

◆ move_initialize() [2/3]

template<typename Allocator, unsigned InlineCapacity>

template<unsigned GreaterI, typename std::enable_if<(InlineCapacity< GreaterI)>::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::move_initialize ( small_vector_base< Allocator, GreaterI > && other )

inlineprotectedinherited

◆ move_initialize() [3/3]

template<typename Allocator, unsigned InlineCapacity>

template<unsigned LessEqualI, typename std::enable_if<(LessEqualI<=InlineCapacity)>::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::move_initialize ( small_vector_base< Allocator, LessEqualI > && other )

inlineprotectednoexceptinherited

◆ move_left() [1/2]

template<typename Allocator, unsigned InlineCapacity>

template<typename V = value_ty, typename std::enable_if< is_memcpyable< V >::value >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::move_left	(	ptr	first,
		ptr	last,
		ptr	d_first )

inlineprotectedinherited

◆ move_left() [2/2]

template<typename Allocator, unsigned InlineCapacity>

template<typename V = value_ty, typename std::enable_if<! is_memcpyable< V >::value >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::move_left	(	ptr	first,
		ptr	last,
		ptr	d_first )

inlineprotectedinherited

◆ move_right() [1/2]

template<typename Allocator, unsigned InlineCapacity>

template<typename V = value_ty, typename std::enable_if< is_memcpyable< V >::value, bool >::type = true>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::move_right	(	ptr	first,
		ptr	last,
		ptr	d_last )

inlineprotectedinherited

◆ move_right() [2/2]

template<typename Allocator, unsigned InlineCapacity>

template<typename V = value_ty, typename std::enable_if<! is_memcpyable< V >::value, bool >::type = false>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::move_right	(	ptr	first,
		ptr	last,
		ptr	d_last )

inlineprotectedinherited

◆ num_uninitialized()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_NODISCARD constexpr size_ty PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::num_uninitialized ( void ) const

inlineconstexprnoexceptinherited

◆ numeric_max()

template<typename Allocator, unsigned InlineCapacity>

template<typename Integer>

static PLUMED_GCH_NODISCARD PLUMED_GCH_CONSTEVAL std::size_t PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::numeric_max ( void )

inlinestaticprotectednoexceptinherited

◆ operator=() [1/3]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR small_vector & PLMD::gch::small_vector< T, InlineCapacity, Allocator >::operator= ( const small_vector< T, InlineCapacity, Allocator > & other )

inline

◆ operator=() [2/3]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR small_vector & PLMD::gch::small_vector< T, InlineCapacity, Allocator >::operator= ( small_vector< T, InlineCapacity, Allocator > && other )

inlinenoexcept

◆ operator=() [3/3]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR small_vector & PLMD::gch::small_vector< T, InlineCapacity, Allocator >::operator= ( std::initializer_list< value_type > ilist )

inline

◆ operator[]() [1/2]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP14_CONSTEXPR reference PLMD::gch::small_vector< T, InlineCapacity, Allocator >::operator[] ( size_type pos )

inline

◆ operator[]() [2/2]

template<typename T, unsigned InlineCapacity, typename Allocator>

const_reference PLMD::gch::small_vector< T, InlineCapacity, Allocator >::operator[] ( size_type pos ) const

inlineconstexpr

◆ pop_back()

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::small_vector< T, InlineCapacity, Allocator >::pop_back ( void )

inline

◆ ptr_cast()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::ptr_cast ( const small_vector_iterator< cptr, diff_ty > & it )

inlineprotectednoexceptinherited

◆ push_back() [1/2]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::small_vector< T, InlineCapacity, Allocator >::push_back ( const_reference value )

inline

◆ push_back() [2/2]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::small_vector< T, InlineCapacity, Allocator >::push_back ( value_type && value )

inline

◆ rbegin() [1/2]

template<typename T, unsigned InlineCapacity, typename Allocator>

const_reverse_iterator PLMD::gch::small_vector< T, InlineCapacity, Allocator >::rbegin ( void ) const

inlineconstexprnoexcept

◆ rbegin() [2/2]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP14_CONSTEXPR reverse_iterator PLMD::gch::small_vector< T, InlineCapacity, Allocator >::rbegin ( void )

inlinenoexcept

◆ rend() [1/2]

template<typename T, unsigned InlineCapacity, typename Allocator>

const_reverse_iterator PLMD::gch::small_vector< T, InlineCapacity, Allocator >::rend ( void ) const

inlineconstexprnoexcept

◆ rend() [2/2]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP14_CONSTEXPR reverse_iterator PLMD::gch::small_vector< T, InlineCapacity, Allocator >::rend ( void )

inlinenoexcept

◆ request_capacity()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::request_capacity ( size_ty request )

inlineprotectedinherited

◆ reserve()

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::small_vector< T, InlineCapacity, Allocator >::reserve ( size_type new_capacity )

inline

◆ reset_data()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::reset_data	(	ptr	data_ptr,
		size_ty	capacity,
		size_ty	size )

inlineprivateinherited

◆ resize() [1/2]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::small_vector< T, InlineCapacity, Allocator >::resize ( size_type count )

inline

◆ resize() [2/2]

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::small_vector< T, InlineCapacity, Allocator >::resize	(	size_type	count,
		const_reference	value )

inline

◆ resize_with()

template<typename Allocator, unsigned InlineCapacity>

template<typename ... ValueT>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::resize_with	(	size_ty	new_size,
		const ValueT &...	val )

inlineprotectedinherited

◆ set_capacity()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::set_capacity ( size_ty capacity )

inlineprivatenoexceptinherited

◆ set_data()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::set_data	(	ptr	data_ptr,
		size_ty	capacity,
		size_ty	size )

inlineprivatenoexceptinherited

◆ set_data_ptr()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::set_data_ptr ( ptr data_ptr )

inlineprivatenoexceptinherited

◆ set_default()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::set_default ( void )

inlineinherited

◆ set_size()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::set_size ( size_ty size )

inlineprivatenoexceptinherited

◆ set_to_inline_storage()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::set_to_inline_storage ( void )

inlineprotectedinherited

◆ shift_into_uninitialized()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::shift_into_uninitialized	(	ptr	pos,
		size_ty	n_shift )

inlineprotectedinherited

◆ shrink_to_fit()

template<typename T, unsigned InlineCapacity, typename Allocator>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::small_vector< T, InlineCapacity, Allocator >::shrink_to_fit ( void )

inline

◆ shrink_to_size()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::shrink_to_size ( void )

inlineprotectedinherited

◆ size()

template<typename T, unsigned InlineCapacity, typename Allocator>

size_type PLMD::gch::small_vector< T, InlineCapacity, Allocator >::size ( void ) const

inlineconstexprnoexcept

◆ storage_ptr() [1/2]

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_NODISCARD constexpr cptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::storage_ptr ( void ) const

inlineconstexprnoexceptinherited

◆ storage_ptr() [2/2]

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::storage_ptr ( void )

inlinenoexceptinherited

◆ swap() [1/2]

template<typename Allocator, unsigned InlineCapacity>

template<typename A = alloc_ty, typename std::enable_if< allocations_are_swappable< A >::value &&InlineCapacity==0 >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::swap ( small_vector_base< Allocator, InlineCapacity > & other )

inlineprotectednoexceptinherited

◆ swap() [2/2]

template<typename T, unsigned InlineCapacity, typename Allocator>

template<typename ValueType = value_type, typename std::enable_if<(std::is_move_constructible< ValueType >::value &&std::is_move_assignable< ValueType >::value)||((std::is_same< std::allocator< value_type >, Allocator >::value||std::allocator_traits< Allocator >::propagate_on_container_swap::value) &&InlineCapacity==0) >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::small_vector< T, InlineCapacity, Allocator >::swap ( small_vector< T, InlineCapacity, Allocator > & other )

inlinenoexcept

◆ swap_allocation()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::swap_allocation ( small_vector_base< Allocator, InlineCapacity > & other )

inlineprivatenoexceptinherited

◆ swap_capacity()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::swap_capacity ( small_vector_base< Allocator, InlineCapacity > & other )

inlineprivatenoexceptinherited

◆ swap_data_ptr()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::swap_data_ptr ( small_vector_base< Allocator, InlineCapacity > & other )

inlineprivatenoexceptinherited

◆ swap_default()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::swap_default ( small_vector_base< Allocator, InlineCapacity > & other )

inlineprotectednoexceptinherited

◆ swap_elements()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::swap_elements ( small_vector_base< Allocator, InlineCapacity > & other )

inlineprotectednoexceptinherited

◆ swap_size()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::swap_size ( small_vector_base< Allocator, InlineCapacity > & other )

inlineprivatenoexceptinherited

◆ swap_unequal_no_propagate()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::swap_unequal_no_propagate ( small_vector_base< Allocator, InlineCapacity > & other )

inlineprotectedinherited

◆ throw_allocation_size_error()

template<typename Allocator, unsigned InlineCapacity>

static PLUMED_GCH_NORETURN PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::throw_allocation_size_error ( void )

inlinestaticprotectedinherited

◆ throw_increment_error()

template<typename Allocator, unsigned InlineCapacity>

static PLUMED_GCH_NORETURN PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::throw_increment_error ( void )

inlinestaticprotectedinherited

◆ throw_index_error()

template<typename Allocator, unsigned InlineCapacity>

static PLUMED_GCH_NORETURN PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::throw_index_error ( void )

inlinestaticprotectedinherited

◆ throw_overflow_error()

template<typename Allocator, unsigned InlineCapacity>

static PLUMED_GCH_NORETURN PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::throw_overflow_error ( void )

inlinestaticprotectedinherited

◆ throw_range_length_error()

template<typename Allocator>

static PLUMED_GCH_NORETURN PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::allocator_interface< Allocator >::throw_range_length_error ( void )

inlinestaticinherited

◆ to_address() [1/3]

template<typename Allocator, unsigned InlineCapacity>

template<typename Pointer, typename std::enable_if< has_ptr_traits_to_address< Pointer >::value >::type * = nullptr>

static constexpr auto PLMD::gch::detail::allocator_interface< Allocator >::to_address ( const Pointer & p ) -> decltype (std::pointer_traits<Pointer>::to_address (p))

inlinestaticconstexprprotectednoexceptinherited

◆ to_address() [2/3]

template<typename Allocator, unsigned InlineCapacity>

static constexpr const value_ty * PLMD::gch::detail::allocator_interface< Allocator >::to_address ( const value_ty * p )

inlinestaticconstexprprotectednoexceptinherited

◆ to_address() [3/3]

template<typename Allocator, unsigned InlineCapacity>

static constexpr value_ty * PLMD::gch::detail::allocator_interface< Allocator >::to_address ( value_ty * p )

inlinestaticconstexprprotectednoexceptinherited

◆ unchecked_advance()

template<typename Allocator, unsigned InlineCapacity>

template<typename Iterator, typename IteratorDiffT = typename std::iterator_traits<Iterator>::difference_type, typename Integer = IteratorDiffT>

static PLUMED_GCH_CPP17_CONSTEXPR void PLMD::gch::detail::allocator_interface< Allocator >::unchecked_advance	(	Iterator &	pos,
		Integer	n )

inlinestaticprotectednoexceptinherited

◆ unchecked_allocate() [1/2]

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::unchecked_allocate ( size_ty n )

inlineprivateinherited

◆ unchecked_allocate() [2/2]

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::unchecked_allocate	(	size_ty	n,
		cptr	hint )

inlineprivateinherited

◆ unchecked_calculate_new_capacity()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR size_ty PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::unchecked_calculate_new_capacity ( const size_ty minimum_required_capacity ) const

inlineprotectednoexceptinherited

◆ unchecked_next()

template<typename Allocator, unsigned InlineCapacity>

template<typename Iterator, typename IteratorDiffT = typename std::iterator_traits<Iterator>::difference_type, typename Integer = IteratorDiffT>

static PLUMED_GCH_NODISCARD PLUMED_GCH_CPP17_CONSTEXPR Iterator PLMD::gch::detail::allocator_interface< Allocator >::unchecked_next	(	Iterator	pos,
		Integer	n = 1 )

inlinestaticprotectednoexceptinherited

◆ unchecked_prev()

template<typename Allocator, unsigned InlineCapacity>

template<typename Iterator, typename IteratorDiffT = typename std::iterator_traits<Iterator>::difference_type, typename Integer = IteratorDiffT>

static PLUMED_GCH_NODISCARD PLUMED_GCH_CPP17_CONSTEXPR Iterator PLMD::gch::detail::allocator_interface< Allocator >::unchecked_prev	(	Iterator	pos,
		Integer	n = 1 )

inlinestaticprotectednoexceptinherited

◆ uninitialized_copy() [1/3]

template<typename Allocator, unsigned InlineCapacity>

template<typename ForwardIt, typename std::enable_if< is_uninitialized_memcpyable_iterator< ForwardIt >::value, bool >::type = true>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::allocator_interface< Allocator >::uninitialized_copy	(	ForwardIt	first,
		ForwardIt	last,
		ptr	dest )

inlineprotectednoexceptinherited

◆ uninitialized_copy() [2/3]

template<typename Allocator, unsigned InlineCapacity>

template<typename InputIt, typename std::enable_if< ! is_uninitialized_memcpyable_iterator< InputIt >::value, bool >::type = false>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::allocator_interface< Allocator >::uninitialized_copy	(	InputIt	first,
		InputIt	last,
		ptr	d_first )

inlineprotectedinherited

◆ uninitialized_copy() [3/3]

template<typename Allocator, unsigned InlineCapacity>

template<typename ForwardIt, typename std::enable_if< is_uninitialized_memcpyable_iterator< ForwardIt >::value, bool >::type = true>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::allocator_interface< Allocator >::uninitialized_copy	(	std::move_iterator< ForwardIt >	first,
		std::move_iterator< ForwardIt >	last,
		ptr	dest )

inlineprotectednoexceptinherited

◆ uninitialized_fill() [1/2]

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::allocator_interface< Allocator >::uninitialized_fill	(	ptr	first,
		ptr	last )

inlineprotectedinherited

◆ uninitialized_fill() [2/2]

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::allocator_interface< Allocator >::uninitialized_fill	(	ptr	first,
		ptr	last,
		const value_ty &	val )

inlineprotectedinherited

◆ uninitialized_move() [1/2]

template<typename Allocator, unsigned InlineCapacity>

template<typename Policy = void, typename V = value_ty, typename std::enable_if<! is_explicitly_move_insertable< V >::value||(std::is_same< Policy, strong_exception_policy >::value &&! relocate_with_move< V >::value), bool >::type = false>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::uninitialized_move	(	ptr	first,
		ptr	last,
		ptr	d_first )

inlineprotectednoexceptinherited

◆ uninitialized_move() [2/2]

template<typename Allocator, unsigned InlineCapacity>

template<typename Policy = void, typename V = value_ty, typename std::enable_if< is_explicitly_move_insertable< V >::value &&(! std::is_same< Policy, strong_exception_policy >::value||relocate_with_move< V >::value), bool >::type = true>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::uninitialized_move	(	ptr	first,
		ptr	last,
		ptr	d_first )

inlineprotectednoexceptinherited

◆ uninitialized_value_construct()

template<typename Allocator, unsigned InlineCapacity>

template<typename A = alloc_ty, typename V = value_ty, typename std::enable_if< is_trivially_constructible< V >::value &&! must_use_alloc_construct< A, V >::value >::type * = nullptr>

PLUMED_GCH_CPP20_CONSTEXPR ptr PLMD::gch::detail::allocator_interface< Allocator >::uninitialized_value_construct	(	ptr	first,
		ptr	last )

inlineprotectedinherited

◆ wipe()

template<typename Allocator, unsigned InlineCapacity>

PLUMED_GCH_CPP20_CONSTEXPR void PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::wipe ( void )

inlineprivateinherited

Friends And Related Symbol Documentation

◆ small_vector

template<typename T, unsigned InlineCapacity, typename Allocator>

template<typename SameT, unsigned DifferentInlineCapacity, typename SameAllocator>

friend class small_vector

friend

Member Data Documentation

◆ bypass

template<typename Allocator, unsigned InlineCapacity>

struct PLMD::gch::detail::small_vector_base::bypass_tag PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::bypass

staticinherited

◆ inline_capacity_v

template<typename T, unsigned InlineCapacity, typename Allocator>

unsigned PLMD::gch::small_vector< T, InlineCapacity, Allocator >::inline_capacity_v = InlineCapacity

staticconstexpr

◆ m_data

template<typename Allocator, unsigned InlineCapacity>

small_vector_data<ptr, size_type, value_ty, InlineCapacity> PLMD::gch::detail::small_vector_base< Allocator, InlineCapacity >::m_data

privateinherited

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

small_vector/small_vector.h

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Friends

Member Typedef Documentation

◆ alloc_base

◆ alloc_interface

◆ alloc_traits

◆ alloc_ty

◆ allocator_type

◆ base

◆ bool_constant

◆ const_iterator

◆ const_pointer

◆ const_reference

◆ const_reverse_iterator

◆ cptr

◆ cvptr

◆ diff_ty

◆ difference_type

◆ is_complete

◆ is_memcpyable

◆ is_memcpyable_iterator

◆ iterator

◆ pointer

◆ ptr

◆ reference

◆ reverse_iterator

◆ size_ty

◆ size_type

◆ underlying_if_enum_t

◆ value_ty

◆ value_type

◆ void_t

◆ vptr

Constructor & Destructor Documentation

◆ small_vector() [1/15]

◆ small_vector() [2/15]

◆ small_vector() [3/15]

◆ small_vector() [4/15]

◆ small_vector() [5/15]

◆ small_vector() [6/15]

◆ small_vector() [7/15]

◆ small_vector() [8/15]

◆ small_vector() [9/15]

◆ small_vector() [10/15]

◆ small_vector() [11/15]

◆ small_vector() [12/15]

◆ small_vector() [13/15]

◆ small_vector() [14/15]

◆ small_vector() [15/15]

◆ ~small_vector()

Member Function Documentation

◆ allocate()

◆ allocate_with_hint()

◆ allocation_end_ptr() [1/2]

◆ allocation_end_ptr() [2/2]

◆ append() [1/4]

◆ append() [2/4]

◆ append() [3/4]

◆ append() [4/4]

◆ append_copies()

◆ append_element()

◆ append_range() [1/3]

◆ append_range() [2/3]

◆ append_range() [3/3]

◆ assign() [1/7]

◆ assign() [2/7]

◆ assign() [3/7]

◆ assign() [4/7]

◆ assign() [5/7]

◆ assign() [6/7]

◆ assign() [7/7]

◆ assign_with_copies()