Documentation of memory

( foonathan/memory)

allocator_storage< StoragePolicy, Mutex > Class Template Reference

Detailed Description

template<class StoragePolicy, class Mutex>
class foonathan::memory::allocator_storage< StoragePolicy, Mutex >

A RawAllocator that stores another allocator.

The StoragePolicy defines the allocator type being stored and how it is stored. The Mutex controls synchronization of the access.

Requires:
The StoragePolicy itself must not store an instance of this class.

Typedefs

using allocator_type = typename StoragePolicy::allocator_type
 
using storage_policy = StoragePolicy
 
using mutex = Mutex
 
using is_stateful = typename traits::is_stateful
 

Member Functions

 allocator_storage ()=default
 
template<class Alloc >
 allocator_storage (Alloc &&alloc,)
 
template<class OtherPolicy >
 allocator_storage (const allocator_storage< OtherPolicy, Mutex > &other,)
 
bool is_composable () const noexcept
 
 allocator_storage (allocator_storage &&other) noexcept
 
allocator_storageoperator= (allocator_storage &&other) noexcept
 
 allocator_storage (const allocator_storage &)=default
 
allocator_storageoperator= (const allocator_storage &)=default
 
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
 
template<typename Dummy = std::true_type>
void * try_allocate_node (std::size_t size, std::size_t alignment) noexcept
 
template<typename Dummy = std::true_type>
void * try_allocate_array (std::size_t count, std::size_t size, std::size_t alignment) noexcept
 
template<typename Dummy = std::true_type>
bool try_deallocate_node (void *ptr, std::size_t size, std::size_t alignment) noexcept
 
template<typename Dummy = std::true_type>
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.get_allocator(), std::declval< actual_mutex &>())))
 
auto lock () const noexcept -> implementation_defined.get_allocator(), std::declval< actual_mutex &>())))
 

Constructors

§ allocator_storage() [1/5]

allocator_storage ( )
default
Effects:
Creates it by default-constructing the StoragePolicy.
Requires:
The StoragePolicy must be default-constructible.

§ allocator_storage() [2/5]

allocator_storage ( Alloc &&  alloc)
Effects:
Creates it by passing it an allocator. The allocator will be forwarded to the StoragePolicy, it decides whether it will be moved, its address stored or something else.
Requires:
The expression new storage_policy(std::forward<Alloc>(alloc)) must be well-formed, otherwise this constructor does not participate in overload resolution.

§ allocator_storage() [3/5]

allocator_storage ( const allocator_storage< OtherPolicy, Mutex > &  other)
Effects:
Creates it by passing it another allocator_storage with a different StoragePolicy but the same Mutex type. Initializes it with the result of other.get_allocator().
Requires:
The expression new storage_policy(other.get_allocator()) must be well-formed, otherwise this constructor does not participate in overload resolution.

§ allocator_storage() [4/5]

allocator_storage ( allocator_storage< StoragePolicy, Mutex > &&  other)
noexcept
Effects:
Moves the allocator_storage object. A moved-out allocator_storage object must still store a valid allocator object.

§ allocator_storage() [5/5]

allocator_storage ( const allocator_storage< StoragePolicy, Mutex > &  )
default
Effects:
Copies the allocator_storage object.
Requires:
The StoragePolicy must be copyable.

Member Functions

§ operator=() [1/2]

allocator_storage& operator= ( allocator_storage< StoragePolicy, Mutex > &&  other)
noexcept
Effects:
Moves the allocator_storage object. A moved-out allocator_storage object must still store a valid allocator object.

§ operator=() [2/2]

allocator_storage& operator= ( const allocator_storage< StoragePolicy, Mutex > &  )
default
Effects:
Copies the allocator_storage object.
Requires:
The StoragePolicy must be copyable.

§ allocate_node()

void* allocate_node ( std::size_t  size,
std::size_t  alignment 
)
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 
)
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 
)
noexcept
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 
)
noexcept
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
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
Effects:
Calls the function on the stored allocator. The Mutex will be locked during the operation.

§ max_alignment()

std::size_t max_alignment ( ) const
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 
)
noexcept
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 
)
noexcept
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 
)
noexcept
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 
)
noexcept
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())
noexcept
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())
noexcept
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.get_allocator(), std::declval<actual_mutex&>())))
noexcept
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.get_allocator(), std::declval<actual_mutex&>())))
noexcept
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
noexcept
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.