Public Types
using	value_type = BaseValueType

using	allocator_type = typename std::allocator_traits<BaseAllocatorType>::template rebind_alloc<value_type>

using	difference_type = std::ptrdiff_t

using	size_type = std::size_t

Protected Types
template<typename U>
using	reallocate_operation

Protected Member Functions
template<typename UAlloc>
constexpr bool	move_assign_alloc (UAlloc &&rhs, typename std::enable_if_t< std::allocator_traits< std::remove_reference_t< UAlloc > >::propagate_on_container_move_assignment::value > *=nullptr) noexcept(is_pocma_or_is_always_equal< UAlloc >::value)

template<typename UAlloc>
constexpr bool	move_assign_alloc (UAlloc &&rhs, typename std::enable_if_t< !std::allocator_traits< std::remove_reference_t< UAlloc > >::propagate_on_container_move_assignment::value > *=nullptr) noexcept(is_pocma_or_is_always_equal< UAlloc >::value)

template<typename UAlloc>
constexpr bool	copy_assign_alloc (const UAlloc &rhs, typename std::enable_if_t< std::allocator_traits< UAlloc >::propagate_on_container_copy_assignment::value > *=nullptr) noexcept

template<typename UAlloc>
constexpr bool	copy_assign_alloc (const UAlloc &rhs, typename std::enable_if_t<!std::allocator_traits< UAlloc >::propagate_on_container_copy_assignment::value > *=nullptr) noexcept

constexpr void	copy_assign_from (const VariableLengthArrayBase &rhs, const size_type rhs_max_size)

template<typename UAlloc>
constexpr void	move_assign_from (VariableLengthArrayBase &&rhs, const size_type rhs_max_size, typename std::enable_if_t< is_pocma_or_is_always_equal< UAlloc >::value > *=nullptr) noexcept

template<typename UAlloc>
constexpr void	move_assign_from (VariableLengthArrayBase &&rhs, const size_type rhs_max_size, typename std::enable_if_t<!is_pocma_or_is_always_equal< UAlloc >::value > *=nullptr)

constexpr void	reserve (const size_type desired_capacity, const size_type max_size)

template<typename... Args>
constexpr void	resize (size_type new_size, const size_type max_size, Args &&... args)

constexpr void	shrink_to_fit ()

constexpr bool	grow (const size_type max_size)

constexpr	VariableLengthArrayBase (const allocator_type &alloc, value_type *data, size_type initial_capacity, size_type size, size_type max_size_max) noexcept(std::is_nothrow_copy_constructible< allocator_type >::value)

constexpr	VariableLengthArrayBase (const VariableLengthArrayBase &rhs, const allocator_type &rhs_alloc) noexcept(std::is_nothrow_copy_constructible< allocator_type >::value)

constexpr	VariableLengthArrayBase (VariableLengthArrayBase &&rhs) noexcept

template<typename UAlloc>
constexpr	VariableLengthArrayBase (VariableLengthArrayBase &&rhs, const UAlloc &rhs_alloc, typename std::enable_if_t< is_pocma_or_is_always_equal< UAlloc >::value > *=nullptr) noexcept

template<typename UAlloc>
constexpr	VariableLengthArrayBase (VariableLengthArrayBase &&rhs, const UAlloc &rhs_alloc, typename std::enable_if_t<!is_pocma_or_is_always_equal< UAlloc >::value > *=nullptr) noexcept

Static Protected Member Functions
template<typename UAllocator>
static constexpr std::enable_if_t< is_detected< reallocate_operation, UAllocator >::value, value_type > *	reallocate (value_type *data, UAllocator &alloc, std::size_t old_object_count, std::size_t new_object_count)

template<typename UAllocator>
static constexpr std::enable_if_t<!is_detected< reallocate_operation, UAllocator >::value, value_type > *	reallocate (value_type *data, UAllocator &alloc, std::size_t old_object_count, std::size_t new_object_count)

template<typename U>
static constexpr void	fast_destroy (U const src, const size_type src_size_count, typename std::enable_if_t< std::is_trivially_destructible< U >::value > =nullptr) noexcept

template<typename U>
static constexpr void	fast_destroy (U const src, const size_type src_size_count, typename std::enable_if_t<!std::is_trivially_destructible< U >::value > =nullptr) noexcept(std::is_nothrow_destructible< U >::value)

template<typename U>
static constexpr void	fast_deallocate (U const src, const size_type src_size_count, const size_type src_capacity_count, allocator_type &alloc, typename std::enable_if_t< std::is_trivially_destructible< U >::value > =nullptr)

template<typename U>
static constexpr void	fast_deallocate (U const src, const size_type src_size_count, const size_type src_capacity_count, allocator_type &alloc, typename std::enable_if_t<!std::is_trivially_destructible< U >::value > =nullptr)

template<typename InputIt>
static constexpr size_type	fast_copy_assign (value_type *dst, size_type dst_capacity_count, InputIt src) noexcept(noexcept(std::is_nothrow_assignable< value_type, std::remove_pointer_t< InputIt > >::value))

template<typename InputIt>
static constexpr size_type	fast_copy_assign (value_type *dst, size_type dst_capacity_count, InputIt src, size_type src_len_count) noexcept(noexcept(std::is_nothrow_assignable< value_type, std::remove_pointer_t< InputIt > >::value))

template<typename InputIt>
static constexpr size_type	fast_copy_construct (value_type const dst, size_type dst_capacity_count, const InputIt src, size_type src_len_count, allocator_type &alloc, typename std::enable_if_t< is_array_of_type_trivially_copyable< std::add_pointer_t< value_type >, InputIt >::value > =nullptr) noexcept

template<typename InputIt>
static constexpr size_type	fast_copy_construct (value_type const dst, size_type dst_capacity_count, const InputIt src, size_type src_len_count, allocator_type &alloc, typename std::enable_if_t< !is_array_of_type_trivially_copyable< std::add_pointer_t< value_type >, InputIt >::value > =nullptr) noexcept(noexcept(std::allocator_traits< allocator_type >::construct(std::declval< std::add_lvalue_reference_t< allocator_type > >(), std::declval< std::add_pointer_t< value_type > >(), std::declval< std::add_lvalue_reference_t< decltype(std::declval< const InputIt >()[0])> >())))

template<typename InputIt>
static constexpr size_type	fast_forward_construct (value_type const dst, size_type dst_capacity_count, InputIt src, size_type src_len_count, allocator_type &alloc, typename std::enable_if_t< is_array_of_type_trivially_copyable< std::add_pointer_t< value_type >, InputIt >::value > =nullptr)

template<typename InputIt>
static constexpr size_type	fast_forward_construct (value_type const dst, size_type dst_capacity_count, InputIt src, size_type src_len_count, allocator_type &alloc, typename std::enable_if_t< !is_array_of_type_trivially_copyable< std::add_pointer_t< value_type >, InputIt >::value > =nullptr)

template<typename InputIt>
static constexpr size_type	fast_forward_assign (value_type const dst, size_type dst_capacity_count, InputIt src, size_type src_len_count, typename std::enable_if_t< is_array_of_type_trivially_copyable< std::add_pointer_t< value_type >, InputIt >::value > =nullptr)

template<typename InputIt>
static constexpr size_type	fast_forward_assign (value_type const dst, size_type dst_capacity_count, InputIt src, size_type src_len_count, typename std::enable_if_t< !is_array_of_type_trivially_copyable< std::add_pointer_t< value_type >, InputIt >::value > =nullptr)

Protected Attributes
allocator_type	alloc_

value_type *	data_

size_type	capacity_

size_type	size_

size_type	max_size_max_

Member Typedef Documentation

◆ allocator_type

template<typename BaseValueType, typename BaseAllocatorType>

using cetl::VariableLengthArrayBase< BaseValueType, BaseAllocatorType >::allocator_type = typename std::allocator_traits<BaseAllocatorType>::template rebind_alloc<value_type>

Per the std::uses_allocator protocol.

◆ difference_type

template<typename BaseValueType, typename BaseAllocatorType>

using cetl::VariableLengthArrayBase< BaseValueType, BaseAllocatorType >::difference_type = std::ptrdiff_t

STL-like declaration of the container's difference type.

◆ reallocate_operation

template<typename BaseValueType, typename BaseAllocatorType>

template<typename U>

using cetl::VariableLengthArrayBase< BaseValueType, BaseAllocatorType >::reallocate_operation

protected

Initial value:

decltype(std::declval<U>().reallocate(std::declval<value_type*>(), std::size_t(), std::size_t()))

std::declval

T declval(T... args)

std::size_t

◆ size_type

template<typename BaseValueType, typename BaseAllocatorType>

using cetl::VariableLengthArrayBase< BaseValueType, BaseAllocatorType >::size_type = std::size_t

STL-like declaration of the container's size type.

◆ value_type

template<typename BaseValueType, typename BaseAllocatorType>

using cetl::VariableLengthArrayBase< BaseValueType, BaseAllocatorType >::value_type = BaseValueType

STL-like declaration of the container's storage type.

Member Function Documentation

◆ fast_copy_assign() [1/2]

template<typename BaseValueType, typename BaseAllocatorType>

template<typename InputIt>

static constexpr size_type cetl::VariableLengthArrayBase< BaseValueType, BaseAllocatorType >::fast_copy_assign	(	value_type *	dst,
		size_type	dst_capacity_count,
		InputIt	src )

inlinestaticconstexprprotectednoexcept

Copy from src to dst.

Returns: the number of elements copied.

Referenced by cetl::VariableLengthArrayBase< T, Allocator >::fast_copy_construct().

Here is the caller graph for this function:

◆ fast_copy_assign() [2/2]

template<typename BaseValueType, typename BaseAllocatorType>

template<typename InputIt>

static constexpr size_type cetl::VariableLengthArrayBase< BaseValueType, BaseAllocatorType >::fast_copy_assign	(	value_type *	dst,
		size_type	dst_capacity_count,
		InputIt	src,
		size_type	src_len_count )

inlinestaticconstexprprotectednoexcept

Copy from src to dst.

Returns: the number of elements copied.

◆ fast_copy_construct() [1/2]

template<typename BaseValueType, typename BaseAllocatorType>

template<typename InputIt>

static constexpr size_type cetl::VariableLengthArrayBase< BaseValueType, BaseAllocatorType >::fast_copy_construct	(	value_type *const	dst,
		size_type	dst_capacity_count,
		const InputIt	src,
		size_type	src_len_count,
		allocator_type &	alloc,
		typename std::enable_if_t< !is_array_of_type_trivially_copyable< std::add_pointer_t< value_type >, InputIt >::value > *	= nullptr ))[0]

inlinestaticconstexprprotectednoexcept

Copy from src to dst.

Returns: the number of elements copied.

◆ fast_copy_construct() [2/2]

template<typename BaseValueType, typename BaseAllocatorType>

template<typename InputIt>

static constexpr size_type cetl::VariableLengthArrayBase< BaseValueType, BaseAllocatorType >::fast_copy_construct	(	value_type *const	dst,
		size_type	dst_capacity_count,
		const InputIt	src,
		size_type	src_len_count,
		allocator_type &	alloc,
		typename std::enable_if_t< is_array_of_type_trivially_copyable< std::add_pointer_t< value_type >, InputIt >::value > *	= nullptr )

inlinestaticconstexprprotectednoexcept

Copy from src to dst.

Returns: the number of elements copied.

◆ fast_deallocate() [1/2]

template<typename BaseValueType, typename BaseAllocatorType>

template<typename U>

static constexpr void cetl::VariableLengthArrayBase< BaseValueType, BaseAllocatorType >::fast_deallocate	(	U *const	src,
		const size_type	src_size_count,
		const size_type	src_capacity_count,
		allocator_type &	alloc,
		typename std::enable_if_t< std::is_trivially_destructible< U >::value > *	= nullptr )

inlinestaticconstexprprotected

Invokes fast_destroy then deallocates the memory.

Referenced by cetl::VariableLengthArrayBase< T, Allocator >::move_assign_from(), cetl::VariableLengthArrayBase< T, Allocator >::reserve(), and cetl::VariableLengthArrayBase< T, Allocator >::shrink_to_fit().

Here is the caller graph for this function:

◆ fast_deallocate() [2/2]

template<typename BaseValueType, typename BaseAllocatorType>

template<typename U>

static constexpr void cetl::VariableLengthArrayBase< BaseValueType, BaseAllocatorType >::fast_deallocate	(	U *const	src,
		const size_type	src_size_count,
		const size_type	src_capacity_count,
		allocator_type &	alloc,
		typename std::enable_if_t<!std::is_trivially_destructible< U >::value > *	= nullptr )

inlinestaticconstexprprotected

Invokes fast_destroy then deallocates the memory.

◆ fast_destroy() [1/2]

template<typename BaseValueType, typename BaseAllocatorType>

template<typename U>

static constexpr void cetl::VariableLengthArrayBase< BaseValueType, BaseAllocatorType >::fast_destroy	(	U *const	src,
		const size_type	src_size_count,
		typename std::enable_if_t< std::is_trivially_destructible< U >::value > *	= nullptr )

inlinestaticconstexprprotectednoexcept

If trivially destructible then we don't have to call the destructors and this is an no-op.

Referenced by cetl::VariableLengthArrayBase< T, Allocator >::fast_deallocate(), and cetl::VariableLengthArrayBase< T, Allocator >::fast_deallocate().

Here is the caller graph for this function:

◆ fast_destroy() [2/2]

template<typename BaseValueType, typename BaseAllocatorType>

template<typename U>

static constexpr void cetl::VariableLengthArrayBase< BaseValueType, BaseAllocatorType >::fast_destroy	(	U *const	src,
		const size_type	src_size_count,
		typename std::enable_if_t<!std::is_trivially_destructible< U >::value > *	= nullptr )

inlinestaticconstexprprotectednoexcept

If not trivially destructible then we invoke each destructor.

◆ grow()

template<typename BaseValueType, typename BaseAllocatorType>

bool cetl::VariableLengthArrayBase< BaseValueType, BaseAllocatorType >::grow ( const size_type max_size )

inlineconstexprprotected

Grows the capacity of the array ensures amortized, constant-time expansion.

◆ move_assign_from()

template<typename BaseValueType, typename BaseAllocatorType>

template<typename UAlloc>

void cetl::VariableLengthArrayBase< BaseValueType, BaseAllocatorType >::move_assign_from	(	VariableLengthArrayBase< BaseValueType, BaseAllocatorType > &&	rhs,
		const size_type	rhs_max_size,
		typename std::enable_if_t< is_pocma_or_is_always_equal< UAlloc >::value > *	= nullptr )

inlineconstexprprotectednoexcept

This version of move assign is an optimization.

It compiles in the simplest possible runtime for moving from one container to the other. All other implementations require additional checks and branches to perform the move.

◆ reserve()

template<typename BaseValueType, typename BaseAllocatorType>

void cetl::VariableLengthArrayBase< BaseValueType, BaseAllocatorType >::reserve	(	const size_type	desired_capacity,
		const size_type	max_size )

inlineconstexprprotected

Ensure enough memory is allocated to store at least the desired_capacity number of elements.

Parameters

desired_capacity	The number of elements to allocate, but not initialize, memory for.
max_size	The maximum number of elements that can be stored in this container.

Referenced by cetl::VariableLengthArrayBase< T, Allocator >::grow().

Here is the caller graph for this function:

◆ shrink_to_fit()

template<typename BaseValueType, typename BaseAllocatorType>

void cetl::VariableLengthArrayBase< BaseValueType, BaseAllocatorType >::shrink_to_fit ( )

inlineconstexprprotected

Deallocate or reallocate memory such that not more than size() elements can be stored in this object.

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

/__w/CETL/CETL/include/cetl/variable_length_array.hpp

	CETL 0.0.0

Public Types

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Member Typedef Documentation

◆ allocator_type

◆ difference_type

◆ reallocate_operation

◆ size_type

◆ value_type

Member Function Documentation

◆ fast_copy_assign() [1/2]

◆ fast_copy_assign() [2/2]

◆ fast_copy_construct() [1/2]

◆ fast_copy_construct() [2/2]

◆ fast_deallocate() [1/2]

◆ fast_deallocate() [2/2]

◆ fast_destroy() [1/2]

◆ fast_destroy() [2/2]

◆ grow()

◆ move_assign_from()

◆ reserve()

◆ shrink_to_fit()