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 (...)