memory
Typedefs | Member Functions
allocator_storage< StoragePolicy, Mutex > Class Template Reference
Allocator storage

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.

Typedefs

using allocator_type
 
using storage_policy
 
using mutex
 
using 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_storage & operator= (allocator_storage &&other) noexcept
 
 allocator_storage (const allocator_storage &)=default
 
allocator_storage & operator= (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
 
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
 

Constructors

◆ allocator_storage() [1/5]

template<class StoragePolicy, class Mutex>
allocator_storage ( )
default
Effects:
Creates it by default-constructing the StoragePolicy.
Requires:
The StoragePolicy must be default-constructible.
Notes:
The default constructor may create an invalid allocator storage not associated with any allocator. If that is the case, it must not be used.

◆ allocator_storage() [2/5]

template<class StoragePolicy, class Mutex>
template<class Alloc>
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]

template<class StoragePolicy, class Mutex>
template<class OtherPolicy>
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]

template<class StoragePolicy, class Mutex>
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]

template<class StoragePolicy, class Mutex>
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]

template<class StoragePolicy, class Mutex>
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]

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

◆ allocate_node()

template<class StoragePolicy, class Mutex>
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()

template<class StoragePolicy, class Mutex>
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()

template<class StoragePolicy, class Mutex>
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()

template<class StoragePolicy, class Mutex>
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()

template<class StoragePolicy, class Mutex>
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()

template<class StoragePolicy, class Mutex>
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()

template<class StoragePolicy, class Mutex>
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()

template<class StoragePolicy, class Mutex>
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()

template<class StoragePolicy, class Mutex>
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()

template<class StoragePolicy, class Mutex>
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()

template<class StoragePolicy, class Mutex>
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]

template<class StoragePolicy, class Mutex>
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]

template<class StoragePolicy, class Mutex>
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]

template<class StoragePolicy, class Mutex>
auto lock ( ) -> implementation_defined
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]

template<class StoragePolicy, class Mutex>
auto lock ( ) const -> implementation_defined
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()

template<class StoragePolicy, class Mutex>
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.
Generated by   doxygen 1.13.2