std::experimental::pmr::resource_adaptor

From cppreference.com
 
 
Technical specifications
Filesystem library (filesystem TS)
Library fundamentals (library fundamentals TS)
Library fundamentals 2 (library fundamentals TS v2)
Library fundamentals 3 (library fundamentals TS v3)
Extensions for parallelism (parallelism TS)
Extensions for parallelism 2 (parallelism TS v2)
Extensions for concurrency (concurrency TS)
Extensions for concurrency 2 (concurrency TS v2)
Concepts (concepts TS)
Ranges (ranges TS)
Reflection (reflection TS)
Mathematical special functions (special functions TR)
 
 
 
template< class Alloc >

using resource_adaptor = /*resource-adaptor-imp*/<
                             typename std::allocator_traits<Allocator>::

                             template rebind_alloc<char>>;
(library fundamentals TS)
template< class Alloc >
class /*resource-adaptor-imp*/ : public memory_resource; // for exposition only
(library fundamentals TS)

The alias template resource_adaptor adapts the allocator type Alloc with a memory_resource interface. The allocator is rebound to a char value type before it is actually adapted (using the resource-adaptor-imp class template), so that adapting specializations of the same allocator template always yields the same type, regardless of the value type the allocator template is originally instantiated with.

resource-adaptor-imp is a class template whose members are described below. The name resource-adaptor-imp is for exposition purposes only and not normative.

In addition to meeting the Allocator requirements, Allocator must additionally satisfy the following requirements:

The type memory_resorce in this page denotes std::experimental::pmr::memory_resource in LFTS v1 and v2, but denotes std::pmr::memory_resource since LFTS v3.

Member types of resource-adaptor-imp

Member type Definition
allocator_type Alloc

Member functions of resource-adaptor-imp

resource-adaptor-imp::resource-adaptor-imp

/*resource-adaptor-imp*/() = default;
(1) (library fundamentals TS)
/*resource-adaptor-imp*/(const /*resource-adaptor-imp*/& other)
    = default;
(2) (library fundamentals TS)
/*resource-adaptor-imp*/(/*resource-adaptor-imp*/&& other)
    = default;
(3) (library fundamentals TS)
explicit /*resource-adaptor-imp*/(const Alloc& a2);
(4) (library fundamentals TS)
explicit /*resource-adaptor-imp*/(Alloc&& a2);
(5) (library fundamentals TS)
1) Default constructor. Default constructs the wrapped allocator.
2) Copy constructor. Copy constructs the wrapped allocator from the allocator wrapped by other.
3) Move constructor. Move constructs the wrapped allocator from the allocator wrapped by other.
4) Initializes the wrapped allocator with a2.
5) Initializes the wrapped allocator with std::move(a2).

Parameters

other - another resource-adaptor-imp object to copy or move from
a2 - another Alloc object to copy or move from

resource-adaptor-imp::get_allocator

allocator_type get_allocator() const;
(library fundamentals TS)

Returns a copy of the wrapped allocator.

resource-adaptor-imp::operator=

/*resource-adaptor-imp*/& operator=(const /*resource-adaptor-imp*/& other)
    = default;
(library fundamentals TS)

Defaulted copy assignment operator. Copy assigns the wrapped allocator from that of other.

resource-adaptor-imp::do_allocate

protected:
virtual void* do_allocate(std::size_t bytes, std::size_t alignment);
(library fundamentals TS)

Allocates memory using the allocate member function of the wrapped allocator.

resource-adaptor-imp::do_deallocate

protected:
virtual void do_deallocate(void *p, std::size_t bytes, std::size_t alignment);
(library fundamentals TS)

Deallocates the storage pointed to by p using the deallocate member function of the wrapped allocator.

p must have been allocated using the allocate member function of an allocator that compares equal to the wrapped allocator, and must not have been subsequently deallocated.

resource-adaptor-imp::do_is_equal

protected:
virtual bool do_is_equal(const memory_resource& other) const noexcept;
(library fundamentals TS)

Let p be dynamic_cast<const /*resource-adaptor-imp*/*>(&other). If p is a null pointer value, returns false. Otherwise, return the result of comparing the allocators wrapped by *p and *this using operator==.