Documentation of memory

( foonathan/memory)

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 >
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 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