cetl::pf17::pmr::polymorphic_allocator< T > Class Template Reference

#include "cetl/pf17/memory_resource.hpp"

Public Types
using	value_type = T

Public Member Functions
	polymorphic_allocator () noexcept=delete
	polymorphic_allocator (memory_resource *r) noexcept
	polymorphic_allocator (const polymorphic_allocator &)=default
polymorphic_allocator &	operator= (const polymorphic_allocator &)=delete
template<class U>
	polymorphic_allocator (const polymorphic_allocator< U > &rhs) noexcept
T *	allocate (std::size_t object_count)
template<typename U>
std::enable_if< deviant::memory_resource_traits< memory_resource >::is_reallocate_defined::value, U >::type *	reallocate (U *ptr, std::size_t old_object_count, std::size_t new_object_count)
void	deallocate (T *p, size_t object_count) noexcept
memory_resource *	resource () const noexcept
template<typename U, typename... Args>
EnableIfNotPair< U >::return_type	construct (U *p, Args &&... args)
template<class FirstType, class SecondType, class... FirstTypeConstructorArgs, class... SecondTypeConstructorArgs>
void	construct (std::pair< FirstType, SecondType > *p, std::piecewise_construct_t, std::tuple< FirstTypeConstructorArgs... > x, std::tuple< SecondTypeConstructorArgs... > y)
template<class FirstType, class SecondType>
void	construct (std::pair< FirstType, SecondType > *p)
template<class FirstType, class SecondType, class FirstTypeArgType, class SecondTypeArgType>
void	construct (std::pair< FirstType, SecondType > *p, FirstTypeArgType &&x, SecondTypeArgType &&y)
template<class FirstType, class SecondType, class CopyFromFirstType, class CopyFromSecondType>
void	construct (std::pair< FirstType, SecondType > *p, const std::pair< CopyFromFirstType, CopyFromSecondType > &copyFrom)
template<class FirstType, class SecondType, class MoveFromFirstType, class MoveFromSecondType>
void	construct (std::pair< FirstType, FirstType > *p, std::pair< MoveFromFirstType, MoveFromSecondType > &&moveFrom)
template<typename U>
void	destroy (U *p)
polymorphic_allocator	select_on_container_copy_construction () const
std::size_t	max_size () const noexcept

Detailed Description

template<typename T>
class cetl::pf17::pmr::polymorphic_allocator< T >

Adheres to the std::pmr::polymorphic_allocator specification.

Template Parameters

T	The type of object this allocator constructs.

Member Typedef Documentation

value_type

template<typename T>

using cetl::pf17::pmr::polymorphic_allocator< T >::value_type = T

The type of object this allocator constructs.

Constructor & Destructor Documentation

polymorphic_allocator()

template<typename T>

cetl::pf17::pmr::polymorphic_allocator< T >::polymorphic_allocator ( )

deletenoexcept

CETL diverges from the c++ standard here.

By default, the C++ standard provides a new_delete_resource. Because C++14 did not provide standardized support for arbitrary alignment of memory allocations it would inflate CETL significantly to support this functionality. Instead, CETL declines to provide default resources and requires explicit resources are provided in types that would otherwise use a silent default.

References CETL_DEBUG_ASSERT, and polymorphic_allocator().

Referenced by polymorphic_allocator().

Here is the caller graph for this function:

Member Function Documentation

construct()

template<typename T>

template<typename U, typename... Args>

EnableIfNotPair< U >::return_type cetl::pf17::pmr::polymorphic_allocator< T >::construct ( U * p, Args &&... args )

inline

Constructs an object U in the storage p with the given arguments following the uses-allocator protocol for constructors.

See std::uses_allocator_construction_args for a C++20 helper and [allocator.uses.construction] in the C++ specification for a discussion of this protocol.

This signature participates in overload resolution only if U is not an std::pair and if U does not use allocator construction.

This method only throws if the constructor of U throws.

Template Parameters

U	The type to construct.
...Args	The type of arguments to forward to the constructor of U.

Parameters

p	The memory to construct an instance of U within.
...args	The argument to forward to the constructor of U.

Returns

void The type is constructed in-place if U is not an std::pair.

References std::forward().

max_size()

template<typename T>

std::size_t cetl::pf17::pmr::polymorphic_allocator< T >::max_size ( ) const

inlinenoexcept

The maximum number of elements this allocator can create.

Where the allocator is backed by system memory or if the memory_resource provided to this instance does not report a max_size, this is often reported as std::numeric_limits<std::size_t>::max() / sizeof(T).

Returns

The maximum number of elements this allocator can create.

References cetl::pf17::pmr::deviant::memory_resource_traits< T >::max_size().

---

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

• /__w/CETL/CETL/include/cetl/pf17/memory_resource.hpp