wpi::memory::traits_detail Namespace Reference

Classes
struct	allocator_rebinder
struct	allocator_rebinder< Alloc< U, Args... >, T >
struct	allocator_type_impl
struct	error
struct	full_concept
struct	invalid_allocator_concept
struct	is_stateful_impl
struct	is_stateful_impl< Allocator, false >
struct	is_stateful_impl< Allocator, true >
struct	min_concept
struct	std_concept

Typedefs
template<class Allocator >
using	allocator_type

Functions
template<class RawAllocator >
auto	propagate_on_container_swap (std_concept) -> typename RawAllocator::propagate_on_container_swap
template<class RawAllocator >
auto	propagate_on_container_swap (min_concept) -> std::true_type
template<class RawAllocator >
auto	propagate_on_container_move_assignment (std_concept) -> typename RawAllocator::propagate_on_container_move_assignment
template<class RawAllocator >
auto	propagate_on_container_move_assignment (min_concept) -> std::true_type
template<class RawAllocator >
auto	propagate_on_container_copy_assignment (std_concept) -> typename RawAllocator::propagate_on_container_copy_assignment
template<class RawAllocator >
auto	propagate_on_container_copy_assignment (min_concept) -> std::true_type
template<class Allocator >
auto	rebind_impl (int) -> typename Allocator::template rebind< char >::other &
template<class Allocator , typename = typename Allocator::value_type>
auto	rebind_impl (char) -> typename allocator_rebinder< Allocator, char >::type
template<class Allocator >
auto	rebind_impl (...) -> Allocator &
template<class Allocator >
auto	is_stateful (full_concept) -> decltype(typename Allocator::is_stateful{})
template<class Allocator >
auto	is_stateful (min_concept) -> typename is_stateful_impl< Allocator, std::is_empty< Allocator >::value >::type
template<class Allocator >
auto	allocate_node (full_concept, Allocator &alloc, std::size_t size, std::size_t alignment) -> WPI_AUTO_RETURN_TYPE(alloc.allocate_node(size, alignment), void *) template< class Allocator > auto allocate_node(std_concept, Allocator &alloc, std::size_t size, std::size_t) -> WPI_AUTO_RETURN(static_cast< void * >(alloc.allocate(size))) template< class Allocator > error allocate_node(error, Allocator &, std::size_t, std::size_t)
template<class Allocator >
auto	deallocate_node (full_concept, Allocator &alloc, void *ptr, std::size_t size, std::size_t alignment) noexcept -> WPI_AUTO_RETURN_TYPE(alloc.deallocate_node(ptr, size, alignment), void) template< class Allocator > auto deallocate_node(std_concept, Allocator &alloc, void *ptr, std::size_t size, std::size_t) noexcept -> WPI_AUTO_RETURN_TYPE(alloc.deallocate(static_cast< char * >(ptr), size), void) template< class Allocator > error deallocate_node(error, Allocator &, void *, std::size_t, std::size_t)
template<class Allocator >
auto	allocate_array (full_concept, Allocator &alloc, std::size_t count, std::size_t size, std::size_t alignment) -> WPI_AUTO_RETURN_TYPE(alloc.allocate_array(count, size, alignment), void *) template< class Allocator > void *allocate_array(min_concept, Allocator &alloc, std::size_t count, std::size_t size, std::size_t alignment)
template<class Allocator >
auto	deallocate_array (full_concept, Allocator &alloc, void *ptr, std::size_t count, std::size_t size, std::size_t alignment) noexcept -> WPI_AUTO_RETURN_TYPE(alloc.deallocate_array(ptr, count, size, alignment), void) template< class Allocator > void deallocate_array(min_concept, Allocator &alloc, void *ptr, std::size_t count, std::size_t size, std::size_t alignment) noexcept
template<class Allocator >
auto	max_node_size (full_concept, const Allocator &alloc) -> WPI_AUTO_RETURN_TYPE(alloc.max_node_size(), std::size_t) template< class Allocator > std::size_t max_node_size(min_concept, const Allocator &) noexcept
template<class Allocator >
auto	max_array_size (full_concept, const Allocator &alloc) -> WPI_AUTO_RETURN_TYPE(alloc.max_array_size(), std::size_t) template< class Allocator > std::size_t max_array_size(min_concept, const Allocator &alloc)
template<class Allocator >
auto	max_alignment (full_concept, const Allocator &alloc) -> WPI_AUTO_RETURN_TYPE(alloc.max_alignment(), std::size_t) template< class Allocator > std::size_t max_alignment(min_concept, const Allocator &)
template<class Allocator >
auto	try_allocate_node (full_concept, Allocator &alloc, std::size_t size, std::size_t alignment) noexcept -> WPI_AUTO_RETURN_TYPE(alloc.try_allocate_node(size, alignment), void *) template< class Allocator > error try_allocate_node(error, Allocator &, std::size_t, std::size_t)
template<class Allocator >
auto	try_deallocate_node (full_concept, Allocator &alloc, void *ptr, std::size_t size, std::size_t alignment) noexcept -> WPI_AUTO_RETURN_TYPE(alloc.try_deallocate_node(ptr, size, alignment), bool) template< class Allocator > error try_deallocate_node(error, Allocator &, void *, std::size_t, std::size_t)
template<class Allocator >
auto	try_allocate_array (full_concept, Allocator &alloc, std::size_t count, std::size_t size, std::size_t alignment) noexcept -> WPI_AUTO_RETURN_TYPE(alloc.try_allocate_array(count, size, alignment), void *) template< class Allocator > void *try_allocate_array(min_concept, Allocator &alloc, std::size_t count, std::size_t size, std::size_t alignment)
template<class Allocator >
auto	try_deallocate_array (full_concept, Allocator &alloc, void *ptr, std::size_t count, std::size_t size, std::size_t alignment) noexcept -> WPI_AUTO_RETURN_TYPE(alloc.try_deallocate_array(ptr, count, size, alignment), bool) template< class Allocator > bool try_deallocate_array(min_concept, Allocator &alloc, void *ptr, std::size_t count, std::size_t size, std::size_t alignment) noexcept

Typedef Documentation

allocator_type

template<class Allocator >

using wpi::memory::traits_detail::allocator_type

Initial value:

 
                typename std::decay<typename allocator_type_impl<Allocator>::type>::type

Function Documentation

allocate_array()

template<class Allocator >

auto wpi::memory::traits_detail::allocate_array	(	full_concept	,
		Allocator &	alloc,
		std::size_t	count,
		std::size_t	size,
		std::size_t	alignment ) -> WPI_AUTO_RETURN_TYPE(alloc.allocate_array(count, size, alignment), void*) template <class Allocator> void* allocate_array(min_concept, Allocator& alloc, std::size_t count, std::size_t size, std::size_t alignment)

allocate_node()

template<class Allocator >

auto wpi::memory::traits_detail::allocate_node	(	full_concept	,
		Allocator &	alloc,
		std::size_t	size,
		std::size_t	alignment ) -> WPI_AUTO_RETURN_TYPE(alloc.allocate_node(size, alignment), void*) template <class Allocator> auto allocate_node(std_concept, Allocator& alloc, std::size_t size, std::size_t) -> WPI_AUTO_RETURN(static_cast<void*>(alloc.allocate(size))) template <class Allocator> error allocate_node(error, Allocator&, std::size_t, std::size_t)

deallocate_array()

template<class Allocator >

auto wpi::memory::traits_detail::deallocate_array ( full_concept , Allocator & alloc, void * ptr, std::size_t count, std::size_t size, std::size_t alignment ) -> WPI_AUTO_RETURN_TYPE(alloc.deallocate_array(ptr, count, size, alignment), void) template <class Allocator> void deallocate_array(min_concept, Allocator& alloc, void* ptr, std::size_t count, std::size_t size, std::size_t alignment) noexcept

noexcept

deallocate_node()

template<class Allocator >

auto wpi::memory::traits_detail::deallocate_node ( full_concept , Allocator & alloc, void * ptr, std::size_t size, std::size_t alignment ) -> WPI_AUTO_RETURN_TYPE(alloc.deallocate_node(ptr, size, alignment), void) template <class Allocator> auto deallocate_node(std_concept, Allocator& alloc, void* ptr, std::size_t size, std::size_t) noexcept -> WPI_AUTO_RETURN_TYPE(alloc.deallocate(static_cast<char*>(ptr), size), void) template <class Allocator> error deallocate_node(error, Allocator&, void*, std::size_t, std::size_t)

noexcept

is_stateful() [1/2]

template<class Allocator >

auto wpi::memory::traits_detail::is_stateful

(

full_concept

)

-> decltype(typename Allocator::is_stateful{})

is_stateful() [2/2]

template<class Allocator >

auto wpi::memory::traits_detail::is_stateful

(

min_concept

)

-> typename is_stateful_impl< Allocator, std::is_empty< Allocator >::value >::type

max_alignment()

template<class Allocator >

auto wpi::memory::traits_detail::max_alignment	(	full_concept	,
		const Allocator &	alloc ) -> WPI_AUTO_RETURN_TYPE(alloc.max_alignment(), std::size_t) template <class Allocator> std::size_t max_alignment(min_concept, const Allocator&)

max_array_size()

template<class Allocator >

auto wpi::memory::traits_detail::max_array_size	(	full_concept	,
		const Allocator &	alloc ) -> WPI_AUTO_RETURN_TYPE(alloc.max_array_size(), std::size_t) template <class Allocator> std::size_t max_array_size(min_concept, const Allocator& alloc)

max_node_size()

template<class Allocator >

auto wpi::memory::traits_detail::max_node_size	(	full_concept	,
		const Allocator &	alloc ) -> WPI_AUTO_RETURN_TYPE(alloc.max_node_size(), std::size_t) template <class Allocator> std::size_t max_node_size(min_concept, const Allocator&) noexcept

propagate_on_container_copy_assignment() [1/2]

template<class RawAllocator >

auto wpi::memory::traits_detail::propagate_on_container_copy_assignment

(

min_concept

)

-> std::true_type

propagate_on_container_copy_assignment() [2/2]

template<class RawAllocator >

auto wpi::memory::traits_detail::propagate_on_container_copy_assignment

(

std_concept

)

-> typename RawAllocator::propagate_on_container_copy_assignment

propagate_on_container_move_assignment() [1/2]

template<class RawAllocator >

auto wpi::memory::traits_detail::propagate_on_container_move_assignment

(

min_concept

)

-> std::true_type

propagate_on_container_move_assignment() [2/2]

template<class RawAllocator >

auto wpi::memory::traits_detail::propagate_on_container_move_assignment

(

std_concept

)

-> typename RawAllocator::propagate_on_container_move_assignment

propagate_on_container_swap() [1/2]

template<class RawAllocator >

auto wpi::memory::traits_detail::propagate_on_container_swap

(

min_concept

)

-> std::true_type

propagate_on_container_swap() [2/2]

template<class RawAllocator >

auto wpi::memory::traits_detail::propagate_on_container_swap

(

std_concept

)

-> typename RawAllocator::propagate_on_container_swap

rebind_impl() [1/3]

template<class Allocator >

auto wpi::memory::traits_detail::rebind_impl

(

...

)

-> Allocator &

rebind_impl() [2/3]

template<class Allocator , typename = typename Allocator::value_type>

auto wpi::memory::traits_detail::rebind_impl

(

char

)

-> typename allocator_rebinder< Allocator, char >::type

rebind_impl() [3/3]

template<class Allocator >

auto wpi::memory::traits_detail::rebind_impl

(

int

)

-> typename Allocator::template rebind< char >::other &

try_allocate_array()

template<class Allocator >

auto wpi::memory::traits_detail::try_allocate_array ( full_concept , Allocator & alloc, std::size_t count, std::size_t size, std::size_t alignment ) -> WPI_AUTO_RETURN_TYPE(alloc.try_allocate_array(count, size, alignment), void*) template <class Allocator> void* try_allocate_array(min_concept, Allocator& alloc, std::size_t count, std::size_t size, std::size_t alignment)

noexcept

try_allocate_node()

template<class Allocator >

auto wpi::memory::traits_detail::try_allocate_node ( full_concept , Allocator & alloc, std::size_t size, std::size_t alignment ) -> WPI_AUTO_RETURN_TYPE(alloc.try_allocate_node(size, alignment), void*) template <class Allocator> error try_allocate_node(error, Allocator&, std::size_t, std::size_t)

noexcept

try_deallocate_array()

template<class Allocator >

auto wpi::memory::traits_detail::try_deallocate_array ( full_concept , Allocator & alloc, void * ptr, std::size_t count, std::size_t size, std::size_t alignment ) -> WPI_AUTO_RETURN_TYPE(alloc.try_deallocate_array(ptr, count, size, alignment), bool) template <class Allocator> bool try_deallocate_array(min_concept, Allocator& alloc, void* ptr, std::size_t count, std::size_t size, std::size_t alignment) noexcept

noexcept

try_deallocate_node()

template<class Allocator >

auto wpi::memory::traits_detail::try_deallocate_node ( full_concept , Allocator & alloc, void * ptr, std::size_t size, std::size_t alignment ) -> WPI_AUTO_RETURN_TYPE(alloc.try_deallocate_node(ptr, size, alignment), bool) template <class Allocator> error try_deallocate_node(error, Allocator&, void*, std::size_t, std::size_t)

noexcept