Class template resource_adaptor_imp

boost::container::pmr::resource_adaptor_imp

Synopsis

// In header: <boost/container/pmr/resource_adaptor.hpp>

template<typename Allocator> 
class resource_adaptor_imp : public boost::container::pmr::memory_resource {
public:
  // types
  typedef Allocator allocator_type;

  // construct/copy/destruct
  resource_adaptor_imp();
  resource_adaptor_imp(const resource_adaptor_imp &);
  resource_adaptor_imp(resource_adaptor_imp &&);
  explicit resource_adaptor_imp(const Allocator &);
  explicit resource_adaptor_imp(Allocator &&);
  resource_adaptor_imp & operator=(const resource_adaptor_imp &);
  resource_adaptor_imp & operator=(resource_adaptor_imp &&);

  // public member functions
  allocator_type & get_allocator();
  const allocator_type & get_allocator() const;

  // protected member functions
  virtual void * do_allocate(std::size_t, std::size_t);
  virtual void do_deallocate(void *, std::size_t, std::size_t);
  virtual bool do_is_equal(const memory_resource &) const noexcept;

  // private member functions
  void * priv_aligned_alloc(std::size_t, std::size_t);
  void priv_aligned_dealloc(void *, std::size_t, std::size_t);

  // private static functions
  static void * priv_bookeeping_addr_from_aligned_ptr(void *);
  static std::size_t priv_extra_bytes_for_overalignment(std::size_t);
  static std::size_t priv_guaranteed_allocator_alignment();
};

Description

An instance of resource_adaptor<Allocator> is an adaptor that wraps a memory_resource interface around Allocator. In order that resource_adaptor<X<T>> and resource_adaptor<X<underline>> are the same type for any allocator template X and types T and U, resource_adaptor<Allocator> is rendered as an alias to this class template such that Allocator is rebound to a char value type in every specialization of the class template. The requirements on this class template are defined below. In addition to the Allocator requirements, the parameter to resource_adaptor shall meet the following additional requirements:</underline>

typename allocator_traits<Allocator>:: pointer shall be identical to typename allocator_traits<Allocator>:: value_type*.
typename allocator_traits<Allocator>:: const_pointer shall be identical to typename allocator_traits<Allocator>:: value_type const*.
typename allocator_traits<Allocator>:: void_pointer shall be identical to void*.
typename allocator_traits<Allocator>:: const_void_pointer shall be identical to void const*.

</underline>

`resource_adaptor_imp` public construct/copy/destruct

```
resource_adaptor_imp();
```
Effects: Default constructs m_alloc.

resource_adaptor_imp(const resource_adaptor_imp & other);

Effects: Copy constructs m_alloc.

resource_adaptor_imp(resource_adaptor_imp && other);

Effects: Move constructs m_alloc.

explicit resource_adaptor_imp(const Allocator & a2);

Effects: Initializes m_alloc with a2.

explicit resource_adaptor_imp(Allocator && a2);

Effects: Initializes m_alloc with a2.

resource_adaptor_imp & operator=(const resource_adaptor_imp & other);

Effects: Copy assigns m_alloc.

resource_adaptor_imp & operator=(resource_adaptor_imp && other);

Effects: Move assigns m_alloc.

`resource_adaptor_imp` public member functions

```
allocator_type & get_allocator();
```
Effects: Returns m_alloc.

const allocator_type & get_allocator() const;

Effects: Returns m_alloc.

`resource_adaptor_imp` protected member functions

```
virtual void * do_allocate(std::size_t bytes, std::size_t alignment);
```
Returns: Allocated memory obtained by calling m_alloc.allocate. The size and alignment of the allocated memory shall meet the requirements for a class derived from memory_resource.
```
virtual void do_deallocate(void * p, std::size_t bytes, std::size_t alignment);
```
Requires: p was previously allocated using A.allocate, where A == m_alloc, and not subsequently deallocated.

Effects: Returns memory to the allocator using m_alloc.deallocate().
```
virtual bool do_is_equal(const memory_resource & other) const noexcept;
```
Let p be dynamic_cast<const resource_adaptor_imp*>(&other).

Returns: false if p is null, otherwise the value of m_alloc == p->m_alloc.

`resource_adaptor_imp` private member functions

void * priv_aligned_alloc(std::size_t bytes, std::size_t alignment);

void priv_aligned_dealloc(void * aligned_ptr, std::size_t bytes, 
                          std::size_t alignment);

`resource_adaptor_imp` private static functions

static void * priv_bookeeping_addr_from_aligned_ptr(void * aligned_ptr);

static std::size_t priv_extra_bytes_for_overalignment(std::size_t alignment);

static std::size_t priv_guaranteed_allocator_alignment();

Boost C++ Libraries