memory
Typedefs | Member Functions | Related Symbols
allocator_adapter< RawAllocator > Class Template Reference
Allocator storage

Detailed Description

template<class RawAllocator>
class foonathan::memory::allocator_adapter< RawAllocator >

An alias template for allocator_storage using the direct_storage policy without a mutex.

It has the effect of giving any RawAllocator the interface with all member functions, avoiding the need to wrap it inside the allocator_traits.

Typedefs

using allocator_type
 
using storage_policy
 
using mutex
 
using is_stateful
 

Member Functions

bool is_composable () const noexcept
 
void * allocate_node (std::size_t size, std::size_t alignment)
 
void * allocate_array (std::size_t count, std::size_t size, std::size_t alignment)
 
void deallocate_node (void *ptr, std::size_t size, std::size_t alignment) noexcept
 
void deallocate_array (void *ptr, std::size_t count, std::size_t size, std::size_t alignment) noexcept
 
std::size_t max_node_size () const
 
std::size_t max_array_size () const
 
std::size_t max_alignment () const
 
void * try_allocate_node (std::size_t size, std::size_t alignment) noexcept
 
void * try_allocate_array (std::size_t count, std::size_t size, std::size_t alignment) noexcept
 
bool try_deallocate_node (void *ptr, std::size_t size, std::size_t alignment) noexcept
 
bool try_deallocate_array (void *ptr, std::size_t count, std::size_t size, std::size_t alignment) noexcept
 
auto get_allocator () noexcept -> decltype(std::declval< storage_policy >().get_allocator())
 
auto get_allocator () const noexcept -> decltype(std::declval< const storage_policy >().get_allocator())
 
auto lock () noexcept -> implementation_defined
 
auto lock () const noexcept -> implementation_defined
 

Related Symbols

template<class RawAllocator>
auto make_allocator_adapter (RawAllocator &&allocator) noexcept -> allocator_adapter< typename std::decay< RawAllocator >::type >
 

Member Functions

◆ allocate_node()

void * allocate_node ( std::size_t size,
std::size_t alignment )
inherited
Effects:
Calls the function on the stored allocator. The Mutex will be locked during the operation.

◆ allocate_array()

void * allocate_array ( std::size_t count,
std::size_t size,
std::size_t alignment )
inherited
Effects:
Calls the function on the stored allocator. The Mutex will be locked during the operation.

◆ deallocate_node()

void deallocate_node ( void * ptr,
std::size_t size,
std::size_t alignment )
noexceptinherited
Effects:
Calls the function on the stored allocator. The Mutex will be locked during the operation.

◆ deallocate_array()

void deallocate_array ( void * ptr,
std::size_t count,
std::size_t size,
std::size_t alignment )
noexceptinherited
Effects:
Calls the function on the stored allocator. The Mutex will be locked during the operation.

◆ max_node_size()

std::size_t max_node_size ( ) const
inherited
Effects:
Calls the function on the stored allocator. The Mutex will be locked during the operation.

◆ max_array_size()

std::size_t max_array_size ( ) const
inherited
Effects:
Calls the function on the stored allocator. The Mutex will be locked during the operation.

◆ max_alignment()

std::size_t max_alignment ( ) const
inherited
Effects:
Calls the function on the stored allocator. The Mutex will be locked during the operation.

◆ try_allocate_node()

void * try_allocate_node ( std::size_t size,
std::size_t alignment )
noexceptinherited
Effects:
Calls the function on the stored composable allocator. The Mutex will be locked during the operation.
Requires:
The allocator must be composable, i.e. is_composable() must return true.
Note
This check is done at compile-time where possible, and at runtime in the case of type-erased storage.

◆ try_allocate_array()

void * try_allocate_array ( std::size_t count,
std::size_t size,
std::size_t alignment )
noexceptinherited
Effects:
Calls the function on the stored composable allocator. The Mutex will be locked during the operation.
Requires:
The allocator must be composable, i.e. is_composable() must return true.
Note
This check is done at compile-time where possible, and at runtime in the case of type-erased storage.

◆ try_deallocate_node()

bool try_deallocate_node ( void * ptr,
std::size_t size,
std::size_t alignment )
noexceptinherited
Effects:
Calls the function on the stored composable allocator. The Mutex will be locked during the operation.
Requires:
The allocator must be composable, i.e. is_composable() must return true.
Note
This check is done at compile-time where possible, and at runtime in the case of type-erased storage.

◆ try_deallocate_array()

bool try_deallocate_array ( void * ptr,
std::size_t count,
std::size_t size,
std::size_t alignment )
noexceptinherited
Effects:
Calls the function on the stored composable allocator. The Mutex will be locked during the operation.
Requires:
The allocator must be composable, i.e. is_composable() must return true.
Note
This check is done at compile-time where possible, and at runtime in the case of type-erased storage.

◆ get_allocator() [1/2]

auto get_allocator ( ) -> decltype(std::declval<storage_policy>().get_allocator())
noexceptinherited
Effects:
Forwards to the StoragePolicy.
Returns:
Returns a reference to the stored allocator.
Note
This does not lock the Mutex.

◆ get_allocator() [2/2]

auto get_allocator ( ) const -> decltype(std::declval<const storage_policy>().get_allocator())
noexceptinherited
Effects:
Forwards to the StoragePolicy.
Returns:
Returns a reference to the stored allocator.
Note
This does not lock the Mutex.

◆ lock() [1/2]

auto lock ( ) -> implementation_defined
noexceptinherited
Returns:
A proxy object that acts like a pointer to the stored allocator. It cannot be reassigned to point to another allocator object and only moving is supported, which is destructive. As long as the proxy object lives and is not moved from, the Mutex will be kept locked.

◆ lock() [2/2]

auto lock ( ) const -> implementation_defined
noexceptinherited
Returns:
A proxy object that acts like a pointer to the stored allocator. It cannot be reassigned to point to another allocator object and only moving is supported, which is destructive. As long as the proxy object lives and is not moved from, the Mutex will be kept locked.

◆ is_composable()

bool is_composable ( ) const
noexceptinherited
Returns:
Whether or not the stored allocator is composable, that is you can use the compositioning functions.
Note
Due to type-erased allocators, this function can not be constexpr.

Related Functions

◆ make_allocator_adapter()

template<class RawAllocator>
auto make_allocator_adapter ( RawAllocator && allocator) -> allocator_adapter<typename std::decay<RawAllocator>::type>
related
Returns:
A new allocator_adapter object created by forwarding to the constructor.
Generated by   doxygen 1.13.2