allocator_traits.hpp File Reference

Detailed Description

The default specialization of the foonathan::memory::allocator_traits.

Typedefs
template<class Allocator >
using	allocator_type = typename std::decay< typename allocator_type_impl< Allocator >::type >::type

Classes
struct	allocator_is_raw_allocator< Allocator >
	Traits class that checks whether or not a standard Allocator can be used as RawAllocator. More...
struct	allocator_is_raw_allocator< std::allocator< T > >
	Specialization of allocator_is_raw_allocator that allows std::allocator again. More...
class	allocator_traits< Allocator >
	The default specialization of the allocator_traits for a RawAllocator. More...
struct	is_raw_allocator< T >
	Traits that check whether a type models concept RawAllocator. More...
class	composable_allocator_traits< Allocator >
	The default specialization of the composable_allocator_traits for a ComposableAllocator. More...
struct	is_composable_allocator< T >
	Traits that check whether a type models concept ComposableAllocator. More...

Functions
template<class Allocator >
std::true_type	has_construct (int,)
template<class Allocator >
std::false_type	has_construct (short)
template<class Allocator >
std::true_type	has_destroy (int,)
template<class Allocator >
std::false_type	has_destroy (short)
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) -> decltype(alloc.allocate_node(size, alignment))
template<class Allocator >
auto	allocate_node (std_concept, Allocator &alloc, std::size_t size, std::size_t) -> decltype(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 -> decltype(alloc.deallocate_node(ptr, size, alignment))
template<class Allocator >
auto	deallocate_node (std_concept, Allocator &alloc, void *ptr, std::size_t size, std::size_t) noexcept -> decltype(alloc.deallocate(static_cast< char * >(ptr), size))
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) -> decltype(alloc.allocate_array(count, size, alignment))
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 -> decltype(alloc.deallocate_array(ptr, count, size, alignment))
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) -> decltype(alloc.max_node_size())
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) -> decltype(alloc.max_array_size())
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) -> decltype(alloc.max_alignment())
template<class Allocator >
std::size_t	max_alignment (min_concept, const Allocator &)
template<class RawAllocator >
allocator_traits< RawAllocator >::foonathan_memory_default_traits	alloc_uses_default_traits (RawAllocator &)
std::false_type	alloc_uses_default_traits (...)
template<class Allocator >
auto	try_allocate_node (full_concept, Allocator &alloc, std::size_t size, std::size_t alignment) noexcept -> decltype(alloc.try_allocate_node(size, alignment))
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 -> decltype(alloc.try_deallocate_node(ptr, size, alignment))
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 -> decltype(alloc.try_allocate_array(count, size, alignment))
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 -> decltype(alloc.try_deallocate_array(ptr, count, size, alignment))
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
template<class RawAllocator >
composable_allocator_traits< RawAllocator >::foonathan_memory_default_traits	composable_alloc_uses_default_traits (RawAllocator &)
std::false_type	composable_alloc_uses_default_traits (...)