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.

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

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]

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

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

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.