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

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`.