| Home | Libraries | People | FAQ | More

## 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(size_t, size_t);
      virtual void do_deallocate(void *, size_t, size_t);
      virtual bool do_is_equal(const memory_resource &) const noexcept;
    };

## 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>

<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

1.     resource_adaptor_imp();

   Effects: Default constructs m_alloc.

2.     resource_adaptor_imp(const resource_adaptor_imp & other);

   Effects: Copy constructs m_alloc.

3.     resource_adaptor_imp(resource_adaptor_imp && other);

   Effects: Move constructs m_alloc.

4.     explicit resource_adaptor_imp(const Allocator & a2);

   Effects: Initializes m_alloc with a2.

5.     explicit resource_adaptor_imp(Allocator && a2);

   Effects: Initializes m_alloc with a2.

6.     resource_adaptor_imp & operator=(const resource_adaptor_imp & other);

   Effects: Copy assigns m_alloc.

7.     resource_adaptor_imp & operator=(resource_adaptor_imp && other);

   Effects: Move assigns m_alloc.

### `resource_adaptor_imp` public member functions

1.     allocator_type & get_allocator();

   Effects: Returns m_alloc.

2.     const allocator_type & get_allocator() const;

   Effects: Returns m_alloc.

### `resource_adaptor_imp` protected member functions

1.     virtual void * do_allocate(size_t bytes, 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`.

2.     virtual void do_deallocate(void * p, size_t bytes, 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().

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