struct erased_type { };

The erased_type struct is an empty struct that serves as a placeholder for a type T in situations where the actual type T is determined at runtime. For example, the nested type, allocator_type, is an alias for erased_type in classes that use type-erased allocators (see 8.3).

template <class F, class Tuple>
constexpr decltype(auto) apply(F&& f, Tuple&& t);

Effects:

Given the exposition only function

template <class F, class Tuple, size_t... I>
constexpr decltype(auto) apply_impl(  // exposition only
    F&& f, Tuple&& t, index_sequence<I...>) {
  return std::forward<F>(f)(std::get<I>(std::forward<Tuple>(t))...);
}

Equivalent to

return apply_impl(std::forward<F>(f), std::forward<Tuple>(t),
    make_index_sequence<tuple_size_v<decay_t<Tuple>>>{});

function& operator=(const function& f);

Effects:

function(allocator_arg, ALLOCATOR_OF(*this), f).swap(*this);

Returns:

*this

function& operator=(function&& f);

Effects:

function(allocator_arg, ALLOCATOR_OF(*this), std::move(f)).swap(*this);

Returns:

*this

function& operator=(nullptr_t) noexcept;

Effects:

If *this != nullptr, destroys the target of this.

Postconditions:

!(*this). The memory resource returned by get_memory_resource() after the assignment is equivalent to the memory resource before the assignment. [ Note: the address returned by get_memory_resource() might change — end note ]

Returns:

*this

template<class F> function& operator=(F&& f);

Effects:

function(allocator_arg, ALLOCATOR_OF(*this), std::forward<F>(f)).swap(*this);

Returns:

*this

template<class F> function& operator=(reference_wrapper<F> f);

Effects:

function(allocator_arg, ALLOCATOR_OF(*this), f).swap(*this);

Returns:

*this

void swap(function& other);

Requires:

this->get_memory_resource() == other->get_memory_resource().

Effects:

Interchanges the targets of *this and other.

Remarks:

The allocators of *this and other are not interchanged.

default_searcher(ForwardIterator pat_first, ForwardIterator pat_last,
BinaryPredicate pred = BinaryPredicate());

Effects:

Constructs a default_searcher object, initializing pat_first_ with pat_first, pat_last_ with pat_last, and pred_ with pred.

Throws:

Any exception thrown by the copy constructor of BinaryPredicate or ForwardIterator1.

template<class ForwardIterator2>
ForwardIterator2 operator()(ForwardIterator2 first, ForwardIterator2 last) const;

Effects:

Equivalent to std::search(first, last, pat_first_, pat_last_, pred_).

boyer_moore_searcher(RandomAccessIterator1 pat_first, RandomAccessIterator1 pat_last,
Hash hf = Hash(),
BinaryPredicate pred = BinaryPredicate());

Requires:

The value type of RandomAccessIterator1 shall meet the DefaultConstructible, CopyConstructible, and CopyAssignable requirements.

Requires:

For any two values A and B of the type iterator_traits<RandomAccessIterator1>::value_type, if pred(A,B)==true, then hf(A)==hf(B) shall be true.

Effects:

Constructs a boyer_moore_searcher object, initializing pat_first_ with pat_first, pat_last_ with pat_last, hash_ with hf, and pred_ with pred.

Throws:

Any exception thrown by the copy constructor of RandomAccessIterator1, or by the default constructor, copy constructor, or the copy assignment operator of the value type of RandomAccessIterator1, or the copy constructor or operator() of BinaryPredicate or Hash. May throw bad_alloc if additional memory needed for internal data structures cannot be allocated.

template<class RandomAccessIterator2>
RandomAccessIterator2 operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;

Requires:

RandomAccessIterator1 and RandomAccessIterator2 shall have the same value type.

Effects:

Finds a subsequence of equal values in a sequence.

Returns:

The first iterator i in the range [first, last - (pat_last_ - pat_first_)) such that for every non-negative integer n less than pat_last_ - pat_first_ the following condition holds: pred(*(i + n), *(pat_first_ + n)) != false. Returns first if [pat_first_, pat_last_) is empty, otherwise returns last if no such iterator is found.

Complexity:

At most (last - first) * (pat_last_ - pat_first_) applications of the predicate.

boyer_moore_horspool_searcher(
RandomAccessIterator1 pat_first, RandomAccessIterator1 pat_last,
Hash hf = Hash(), BinaryPredicate pred = BinaryPredicate());

Requires:

The value type of RandomAccessIterator1 shall meet the DefaultConstructible, CopyConstructible, and CopyAssignable requirements.

Requires:

For any two values A and B of the type iterator_traits<RandomAccessIterator1>::value_type, if pred(A,B)==true, then hf(A)==hf(B) shall be true.

Effects:

Constructs a boyer_moore_horspool_searcher object, initializing pat_first_ with pat_first, pat_last_ with pat_last, hash_ with hf, and pred_ with pred.

Throws:

Any exception thrown by the copy constructor of RandomAccessIterator1, or by the default constructor, copy constructor, or the copy assignment operator of the value type of RandomAccessIterator1 or the copy constructor or operator() of BinaryPredicate or Hash. May throw bad_alloc if the system cannot allocate additional memory for internal data structures needed.

template<class RandomAccessIterator2>
RandomAccessIterator2 operator()(RandomAccessIterator2 first, RandomAccessIterator2 last) const;

Requires:

RandomAccessIterator1 and RandomAccessIterator2 shall have the same value type.

Effects:

Finds a subsequence of equal values in a sequence.

Returns:

The first iterator i in the range [first, last - (pat_last_ - pat_first_)) such that for every non-negative integer n less than pat_last_ - pat_first_ the following condition holds: pred(*(i + n), *(pat_first_ + n)) != false. Returns first if [pat_first_, pat_last_) is empty, otherwise returns last if no such iterator is found.

Complexity:

At most (last - first) * (pat_last_ - pat_first_) applications of the predicate.

constexpr optional() noexcept;constexpr optional(nullopt_t) noexcept;

Postconditions:

*this does not contain a value.

Remarks:

No contained value is initialized. For every object type T these constructors shall be constexpr constructors (C++14 §7.1.5).

optional(const optional<T>& rhs);

Requires:

is_copy_constructible_v<T> is true.

Effects:

If rhs contains a value, initializes the contained value as if direct-non-list-initializing an object of type T with the expression *rhs.

Postconditions:

bool(rhs) == bool(*this).

Throws:

Any exception thrown by the selected constructor of T.

optional(optional<T>&& rhs) noexcept(see below);

Requires:

is_move_constructible_v<T> is true.

Effects:

If rhs contains a value, initializes the contained value as if direct-non-list-initializing an object of type T with the expression std::move(*rhs). bool(rhs) is unchanged.

Postconditions:

bool(rhs) == bool(*this).

Throws:

Any exception thrown by the selected constructor of T.

Remarks:

The expression inside noexcept is equivalent to:

is_nothrow_move_constructible_v<T>

constexpr optional(const T& v);

Requires:

is_copy_constructible_v<T> is true.

Effects:

Initializes the contained value as if direct-non-list-initializing an object of type T with the expression v.

Postconditions:

*this contains a value.

Throws:

Any exception thrown by the selected constructor of T.

Remarks:

If T's selected constructor is a constexpr constructor, this constructor shall be a constexpr constructor.

constexpr optional(T&& v);

Requires:

is_move_constructible_v<T> is true.

Effects:

Initializes the contained value as if direct-non-list-initializing an object of type T with the expression std::move(v).

Postconditions:

*this contains a value.

Throws:

Any exception thrown by the selected constructor of T.

Remarks:

If T's selected constructor is a constexpr constructor, this constructor shall be a constexpr constructor.

template <class... Args> constexpr explicit optional(in_place_t, Args&&... args);

Requires:

is_constructible_v<T, Args&&...> is true.

Effects:

Initializes the contained value as if direct-non-list-initializing an object of type T with the arguments std::forward<Args>(args)....

Postconditions:

*this contains a value.

Throws:

Any exception thrown by the selected constructor of T.

Remarks:

If T's constructor selected for the initialization is a constexpr constructor, this constructor shall be a constexpr constructor.

template <class U, class... Args>
constexpr explicit optional(in_place_t, initializer_list<U> il, Args&&... args);

Requires:

is_constructible_v<T, initializer_list<U>&, Args&&...> is true.

Effects:

Initializes the contained value as if direct-non-list-initializing an object of type T with the arguments il, std::forward<Args>(args)....

Postconditions:

*this contains a value.

Throws:

Any exception thrown by the selected constructor of T.

Remarks:

The function shall not participate in overload resolution unless is_constructible_v<T, initializer_list<U>&, Args&&...> is true. If T's constructor selected for the initialization is a constexpr constructor, this constructor shall be a constexpr constructor.

~optional();

Effects:

If is_trivially_destructible_v<T> != true and *this contains a value, calls val->T::~T().

Remarks:

If is_trivially_destructible_v<T> == true then this destructor shall be a trivial destructor.

optional<T>& operator=(nullopt_t) noexcept;

Effects:

If *this contains a value, calls val->T::~T() to destroy the contained value; otherwise no effect.

Returns:

*this.

Postconditions:

*this does not contain a value.

optional<T>& operator=(const optional<T>& rhs);

Requires:

is_copy_constructible_v<T> is true and is_copy_assignable_v<T> is true.

Effects:

Table 4 — optional::operator=(const optional&) effects

	*this contains a value	*this does not contain a value
rhs contains a value	assigns *rhs to the contained value	initializes the contained value as if direct-non-list-initializing an object of type T with *rhs
rhs does not contain a value	destroys the contained value by calling val->T::~T()	no effect

Returns:

*this.

Postconditions:

bool(rhs) == bool(*this).

Remarks:

If any exception is thrown, the result of the expression bool(*this) remains unchanged. If an exception is thrown during the call to T's copy constructor, no effect. If an exception is thrown during the call to T's copy assignment, the state of its contained value is as defined by the exception safety guarantee of T's copy assignment.

optional<T>& operator=(optional<T>&& rhs) noexcept(see below);

Requires:

is_move_constructible_v<T> is true and is_move_assignable_v<T> is true.

Effects:

The result of the expression bool(rhs) remains unchanged.

Table 5 — optional::operator=(optional&&) effects

	*this contains a value	*this does not contain a value
rhs contains a value	assigns std::move(*rhs) to the contained value	initializes the contained value as if direct-non-list-initializing an object of type T with std::move(*rhs)
rhs does not contain a value	destroys the contained value by calling val->T::~T()	no effect

Returns:

*this.

Postconditions:

bool(rhs) == bool(*this).

Remarks:

The expression inside noexcept is equivalent to:

is_nothrow_move_assignable_v<T> && is_nothrow_move_constructible_v<T>

If any exception is thrown, the result of the expression bool(*this) remains unchanged. If an exception is thrown during the call to T's move constructor, the state of *rhs.val is determined by the exception safety guarantee of T's move constructor. If an exception is thrown during the call to T's move assignment, the state of *val and *rhs.val is determined by the exception safety guarantee of T's move assignment.

template <class U> optional<T>& operator=(U&& v);

Requires:

is_constructible_v<T, U> is true and is_assignable_v<T&, U> is true.

Effects:

If *this contains a value, assigns std::forward<U>(v) to the contained value; otherwise initializes the contained value as if direct-non-list-initializing object of type T with std::forward<U>(v).

Returns:

*this.

Postconditions:

*this contains a value.

Remarks:

If any exception is thrown, the result of the expression bool(*this) remains unchanged. If an exception is thrown during the call to T's constructor, the state of v is determined by the exception safety guarantee of T's constructor. If an exception is thrown during the call to T's assignment, the state of *val and v is determined by the exception safety guarantee of T's assignment.

The function shall not participate in overload resolution unless is_same_v<decay_t<U>, T> is true.

Notes:

The reason for providing such generic assignment and then constraining it so that effectively T == U is to guarantee that assignment of the form o = {} is unambiguous.

template <class... Args> void emplace(Args&&... args);

Requires:

is_constructible_v<T, Args&&...> is true.

Effects:

Calls *this = nullopt. Then initializes the contained value as if direct-non-list-initializing an object of type T with the arguments std::forward<Args>(args)....

Postconditions:

*this contains a value.

Throws:

Any exception thrown by the selected constructor of T.

Remarks:

If an exception is thrown during the call to T's constructor, *this does not contain a value, and the previous *val (if any) has been destroyed.

template <class U, class... Args> void emplace(initializer_list<U> il, Args&&... args);

Effects:

Calls *this = nullopt. Then initializes the contained value as if direct-non-list-initializing an object of type T with the arguments il, std::forward<Args>(args)....

Postconditions:

*this contains a value.

Throws:

Any exception thrown by the selected constructor of T.

Remarks:

If an exception is thrown during the call to T's constructor, *this does not contain a value, and the previous *val (if any) has been destroyed.

The function shall not participate in overload resolution unless is_constructible_v<T, initializer_list<U>&, Args&&...> is true.

void swap(optional<T>& rhs) noexcept(see below);

Requires:

Lvalues of type T shall be swappable and is_move_constructible_v<T> is true.

Effects:

Table 6 — optional::swap(optional&) effects

	*this contains a value	*this does not contain a value
rhs contains a value	calls swap(*(*this), *rhs)	initializes the contained value of *this as if direct-non-list-initializing an object of type T with the expression std::move(*rhs), followed by rhs.val->T::~T(); postcondition is that *this contains a value and rhs does not contain a value
rhs does not contain a value	initializes the contained value of rhs as if direct-non-list-initializing an object of type T with the expression std::move(*(*this)), followed by val->T::~T(); postcondition is that *this does not contain a value and rhs contains a value	no effect

Throws:

Any exceptions that the expressions in the Effects element throw.

Remarks:

The expression inside noexcept is equivalent to:

is_nothrow_move_constructible_v<T> && noexcept(swap(declval<T&>(), declval<T&>()))

If any exception is thrown, the results of the expressions bool(*this) and bool(rhs) remain unchanged. If an exception is thrown during the call to function swap the state of *val and *rhs.val is determined by the exception safety guarantee of swap for lvalues of T. If an exception is thrown during the call to T's move constructor, the state of *val and *rhs.val is determined by the exception safety guarantee of T's move constructor.

constexpr T const* operator->() const;constexpr T* operator->();

Requires:

*this contains a value.

Returns:

val.

Throws:

Nothing.

Remarks:

Unless T is a user-defined type with overloaded unary operator&, these functions shall be constexpr functions.

constexpr T const& operator*() const &;constexpr T& operator*() &;

Requires:

*this contains a value.

Returns:

*val.

Throws:

Nothing.

Remarks:

These functions shall be constexpr functions.

constexpr T&& operator*() &&;constexpr const T&& operator*() const &&;

Requires:

*this contains a value

Effects:

Equivalent to return std::move(*val);

constexpr explicit operator bool() const noexcept;

Returns:

true if and only if *this contains a value.

Remarks:

This function shall be a constexpr function.

constexpr T const& value() const &;constexpr T& value() &;

Effects:

Equivalent to return bool(*this) ? *val : throw bad_optional_access();

constexpr T&& value() &&;constexpr const T&& value() const &&;

Effects:

Equivalent to return bool(*this) ? std::move(*val) : throw bad_optional_access();

template <class U> constexpr T value_or(U&& v) const &;

Effects:

Equivalent to return bool(*this) ? **this : static_cast<T>(std::forward<U>(v)).

Remarks:

If is_copy_constructible_v<T> && is_convertible_v<U&&, T> is false, the program is ill-formed.

template <class U> T value_or(U&& v) &&;

Effects:

Equivalent to return bool(*this) ? std::move(**this) : static_cast<T>(std::forward<U>(v)).

Remarks:

If is_move_constructible_v<T> && is_convertible_v<U&&, T> is false, the program is ill-formed.

any() noexcept;

Postconditions:

this->empty()

any(const any& other);

Effects:

Constructs an object of type any with an equivalent state as other.

Throws:

Any exceptions arising from calling the selected constructor of the contained object.

any(any&& other) noexcept;

Effects:

Constructs an object of type any with a state equivalent to the original state of other.

Postconditions:

other is left in a valid but otherwise unspecified state.

template<class ValueType>
any(ValueType&& value);

Let T be equal to decay_t<ValueType>.

Requires:

T shall satisfy the CopyConstructible requirements. If is_copy_constructible_v<T> is false, the program is ill-formed.

Effects:

Constructs an object of type any that contains an object of type T direct-initialized with std::forward<ValueType>(value).

Remarks:

This constructor shall not participate in overload resolution if decay_t<ValueType> is the same type as any.

Throws:

Any exception thrown by the selected constructor of T.

~any();

Effects:

clear().

any& operator=(const any& rhs);

Effects:

any(rhs).swap(*this). No effects if an exception is thrown.

Returns:

*this

Throws:

Any exceptions arising from the copy constructor of the contained object.

any& operator=(any&& rhs) noexcept;

Effects:

any(std::move(rhs)).swap(*this).

Returns:

*this

Postconditions:

The state of *this is equivalent to the original state of rhs and rhs is left in a valid but otherwise unspecified state.

template<class ValueType>
any& operator=(ValueType&& rhs);

Let T be equal to decay_t<ValueType>.

Requires:

T shall satisfy the CopyConstructible requirements. If is_copy_constructible_v<T> is false, the program is ill-formed.

Effects:

Constructs an object tmp of type any that contains an object of type T direct-initialized with std::forward<ValueType>(rhs), and tmp.swap(*this). No effects if an exception is thrown.

Returns:

*this

Remarks:

This operator shall not participate in overload resolution if decay_t<ValueType> is the same type as any.

Throws:

Any exception thrown by the selected constructor of T.

void clear() noexcept;

Effects:

If not empty, destroys the contained object.

Postconditions:

empty() == true.

void swap(any& rhs) noexcept;

Effects:

Exchange the states of *this and rhs.

bool empty() const noexcept;

Returns:

true if *this has no contained object, otherwise false.

const type_info& type() const noexcept;

Returns:

If *this has a contained object of type T, typeid(T); otherwise typeid(void).

[ Note: Useful for querying against types known either at compile time or only at runtime. — end note ]

constexpr size_type find(basic_string_view str, size_type pos = 0) const noexcept;

Effects:

Determines the lowest position xpos, if possible, such that the following conditions obtain:

• pos <= xpos
• xpos + str.size() <= size()
• traits::eq(at(xpos+I), str.at(I)) for all elements I of the string referenced by str.

Returns:

xpos if the function can determine such a value for xpos. Otherwise, returns npos.

Remarks:

Uses traits::eq().

constexpr size_type rfind(basic_string_view str, size_type pos = npos) const noexcept;

Effects:

Determines the highest position xpos, if possible, such that the following conditions obtain:

• xpos <= pos
• xpos + str.size() <= size()
• traits::eq(at(xpos+I), str.at(I)) for all elements I of the string referenced by str.

Returns:

xpos if the function can determine such a value for xpos. Otherwise, returns npos.

Remarks:

Uses traits::eq().

constexpr size_type find_first_of(basic_string_view str, size_type pos = 0) const noexcept;

Effects:

Determines the lowest position xpos, if possible, such that the following conditions obtain:

• pos <= xpos
• xpos < size()
• traits::eq(at(xpos), str.at(I)) for some element I of the string referenced by str.

Returns:

xpos if the function can determine such a value for xpos. Otherwise, returns npos.

Remarks:

Uses traits::eq().

constexpr size_type find_last_of(basic_string_view str, size_type pos = npos) const noexcept;

Effects:

Determines the highest position xpos, if possible, such that the following conditions obtain:

• xpos <= pos
• xpos < size()
• traits::eq(at(xpos), str.at(I)) for some element I of the string referenced by str.

Returns:

xpos if the function can determine such a value for xpos. Otherwise, returns npos.

Remarks:

Uses traits::eq().

constexpr size_type find_first_not_of(basic_string_view str, size_type pos = 0) const noexcept;

Effects:

Determines the lowest position xpos, if possible, such that the following conditions obtain:

• pos <= xpos
• xpos < size()
• traits::eq(at(xpos), str.at(I)) for no element I of the string referenced by str.

Returns:

xpos if the function can determine such a value for xpos. Otherwise, returns npos.

Remarks:

Uses traits::eq().

constexpr size_type find_last_not_of(basic_string_view str, size_type pos = npos) const noexcept;

Effects:

Determines the highest position xpos, if possible, such that the following conditions obtain:

• xpos <= pos
• xpos < size()
• traits::eq(at(xpos), str.at(I)) for no element I of the string referenced by str.

Returns:

xpos if the function can determine such a value for xpos. Otherwise, returns npos.

Remarks:

Uses traits::eq().

~memory_resource();

Effects:

Destroys this memory_resource.

void* allocate(size_t bytes, size_t alignment = max_align);

Effects:

Equivalent to return do_allocate(bytes, alignment);

void deallocate(void* p, size_t bytes, size_t alignment = max_align);

Effects:

Equivalent to do_deallocate(p, bytes, alignment);

bool is_equal(const memory_resource& other) const noexcept;

Effects:

Equivalent to return do_is_equal(other);

virtual void* do_allocate(size_t bytes, size_t alignment) = 0;

Requires:

Alignment shall be a power of two.

Returns:

A derived class shall implement this function to return a pointer to allocated storage (C++14 §3.7.4.2) with a size of at least bytes. The returned storage is aligned to the specified alignment, if such alignment is supported; otherwise it is aligned to max_align.

Throws:

A derived class implementation shall throw an appropriate exception if it is unable to allocate memory with the requested size and alignment.

virtual void do_deallocate(void* p, size_t bytes, size_t alignment) = 0;

Requires:

p shall have been returned from a prior call to allocate(bytes, alignment) on a memory resource equal to *this, and the storage at p shall not yet have been deallocated.

Effects:

A derived class shall implement this function to dispose of allocated storage.

Throws:

Nothing.

virtual bool do_is_equal(const memory_resource& other) const noexcept = 0;

Returns:

A derived class shall implement this function to return true if memory allocated from this can be deallocated from other and vice-versa; otherwise it shall return false. [ Note: The most-derived type of other might not match the type of this. For a derived class, D, a typical implementation of this function will compute dynamic_cast<const D*>(&other) and go no further (i.e., return false) if it returns nullptr. — end note ]

bool operator==(const memory_resource& a, const memory_resource& b) noexcept;

Returns:

&a == &b || a.is_equal(b).

bool operator!=(const memory_resource& a, const memory_resource& b) noexcept;

Returns:

!(a == b).

polymorphic_allocator() noexcept;

Effects:

Sets m_resource to get_default_resource().

polymorphic_allocator(memory_resource* r);

Requires:

r is non-null.

Effects:

Sets m_resource to r.

Throws:

Nothing

Notes:

This constructor provides an implicit conversion from memory_resource*.

template <class U>
polymorphic_allocator(const polymorphic_allocator<U>& other) noexcept;

Effects:

Sets m_resource to other.resource().

Tp* allocate(size_t n);

Returns:

Equivalent to static_cast<Tp*>(m_resource->allocate(n * sizeof(Tp), alignof(Tp))).

void deallocate(Tp* p, size_t n);

Requires:

p was allocated from a memory resource, x, equal to *m_resource, using x.allocate(n * sizeof(Tp), alignof(Tp)).

Effects:

Equivalent to m_resource->deallocate(p, n * sizeof(Tp), alignof(Tp)).

Throws:

Nothing.

template <class T, class... Args>
void construct(T* p, Args&&... args);

Requires:

Uses-allocator construction of T with allocator this->resource() (see 2.1) and constructor arguments std::forward<Args>(args)... is well-formed. [ Note: uses-allocator construction is always well formed for types that do not use allocators. — end note ]

Effects:

Construct a T object at p by uses-allocator construction with allocator this->resource() (2.1) and constructor arguments std::forward<Args>(args)....

Throws:

: Nothing unless the constructor for T throws.

template <class T1, class T2, class... Args1, class... Args2>
void construct(pair<T1,T2>* p, piecewise_construct_t,
               tuple<Args1...> x, tuple<Args2...> y);

Effects:

Let xprime be a tuple constructed from x according to the appropriate rule from the following list. [ Note: The following description can be summarized as constructing a std::pair<T1,T2> object at p as if by separate uses-allocator construction with allocator this->resource() (2.1) of p->first using the elements of x and p->second using the elements of y. — end note ]

• If uses_allocator_v<T1,memory_resource*> is false and is_constructible_v<T,Args1...> is true, then xprime is x.
• Otherwise, if uses_allocator_v<T1,memory_resource*> is true and is_constructible_v<T1,allocator_arg_t,memory_resource*,Args1...> is true, then xprime is tuple_cat(make_tuple(allocator_arg, this->resource()), std::move(x)).
• Otherwise, if uses_allocator_v<T1,memory_resource*> is true and is_constructible_v<T1,Args1...,memory_resource*> is true, then xprime is tuple_cat(std::move(x), make_tuple(this->resource())).
• Otherwise the program is ill formed.

and let yprime be a tuple constructed from y according to the appropriate rule from the following list:

• If uses_allocator_v<T2,memory_resource*> is false and is_constructible_v<T,Args2...> is true, then yprime is y.
• Otherwise, if uses_allocator_v<T2,memory_resource*> is true and is_constructible_v<T2,allocator_arg_t,memory_resource*,Args2...> is true, then yprime is tuple_cat(make_tuple(allocator_arg, this->resource()), std::move(y)).
• Otherwise, if uses_allocator_v<T2,memory_resource*> is true and is_constructible_v<T2,Args2...,memory_resource*> is true, then yprime is tuple_cat(std::move(y), make_tuple(this->resource())).
• Otherwise the program is ill formed.

then this function constructs a std::pair<T1,T2> object at p using constructor arguments piecewise_construct, xprime, yprime.

template <class T1, class T2>
void construct(std::pair<T1,T2>* p);

Effects:

Equivalent to this->construct(p, piecewise_construct, tuple<>(), tuple<>());

template <class T1, class T2, class U, class V>
void construct(std::pair<T1,T2>* p, U&& x, V&& y);

Effects:

Equivalent to this->construct(p, piecewise_construct, forward_as_tuple(std::forward<U>(x)), forward_as_tuple(std::forward<V>(y)));

template <class T1, class T2, class U, class V>
void construct(std::pair<T1,T2>* p, const std::pair<U, V>& pr);

Effects:

Equivalent to this->construct(p, piecewise_construct, forward_as_tuple(pr.first), forward_as_tuple(pr.second));

template <class T1, class T2, class U, class V>
void construct(std::pair<T1,T2>* p, std::pair<U, V>&& pr);

Effects:

Equivalent to this->construct(p, piecewise_construct, forward_as_tuple(std::forward<U>(pr.first)), forward_as_tuple(std::forward<V>(pr.second)));

template <class T>
void destroy(T* p);

Effects:

p->~T().

polymorphic_allocator select_on_container_copy_construction() const;

Returns:

polymorphic_allocator().

memory_resource* resource() const;

Returns:

m_resource.

template <class T1, class T2>
bool operator==(const polymorphic_allocator<T1>& a,
                const polymorphic_allocator<T2>& b) noexcept;

Returns:

*a.resource() == *b.resource().

template <class T1, class T2>
bool operator!=(const polymorphic_allocator<T1>& a,
                const polymorphic_allocator<T2>& b) noexcept;

Returns:

! (a == b)

explicit resource_adaptor_imp(const Allocator& a2);

Effects:

Initializes m_alloc with a2.

explicit resource_adaptor_imp(Allocator&& a2);

Effects:

Initializes m_alloc with std::move(a2).

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 (8.5).

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().

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.

size_t max_blocks_per_chunk;

The maximum number of blocks that will be allocated at once from the upstream memory resource to replenish a pool. If the value of max_blocks_per_chunk is zero or is greater than an implementation-defined limit, that limit is used instead. The implementation may choose to use a smaller value than is specified in this field and may use different values for different pools.

size_t largest_required_pool_block;

The largest allocation size that is required to be fulfilled using the pooling mechanism. Attempts to allocate a single block larger than this threshold will be allocated directly from the upstream memory resource. If largest_required_pool_block is zero or is greater than an implementation-defined limit, that limit is used instead. The implementation may choose a pass-through threshold larger than specified in this field.

synchronized_pool_resource(const pool_options& opts, memory_resource* upstream);unsynchronized_pool_resource(const pool_options& opts, memory_resource* upstream);

Requires:

upstream is the address of a valid memory resource.

Effects:

Constructs a pool resource object that will obtain memory from upstream whenever the pool resource is unable to satisfy a memory request from its own internal data structures. The resulting object will hold a copy of upstream, but will not own the resource to which upstream points. [ Note: The intention is that calls to upstream->allocate() will be substantially fewer than calls to this->allocate() in most cases. — end note ] The behavior of the pooling mechanism is tuned according to the value of the opts argument.

Throws:

Nothing unless upstream->allocate() throws. It is unspecified if or under what conditions this constructor calls upstream->allocate().

virtual ~synchronized_pool_resource();virtual ~unsynchronized_pool_resource();

Effects:

Calls this->release().

void release();

Effects:

Calls upstream_resource()->deallocate() as necessary to release all allocated memory. [ Note: memory is released back to upstream_resource() even if deallocate has not been called for some of the allocated blocks. — end note ]

memory_resource* upstream_resource() const;

Returns:

The value of the upstream argument provided to the constructor of this object.

pool_options options() const;

Returns:

The options that control the pooling behavior of this resource. The values in the returned struct may differ from those supplied to the pool resource constructor in that values of zero will be replaced with implementation-defined defaults and sizes may be rounded to unspecified granularity.

virtual void* do_allocate(size_t bytes, size_t alignment);

Returns:

A pointer to allocated storage (C++14 §3.7.4.2) with a size of at least bytes. The size and alignment of the allocated memory shall meet the requirements for a class derived from memory_resource (8.5).

Effects:

If the pool selected for a block of size bytes is unable to satisfy the memory request from its own internal data structures, it will call upstream_resource()->allocate() to obtain more memory. If bytes is larger than that which the largest pool can handle, then memory will be allocated using upstream_resource()->allocate().

Throws:

Nothing unless upstream_resource()->allocate() throws.

virtual void do_deallocate(void* p, size_t bytes, size_t alignment);

Effects:

Return the memory at p to the pool. It is unspecified if or under what circumstances this operation will result in a call to upstream_resource()->deallocate().

Throws:

Nothing

virtual bool unsynchronized_pool_resource::do_is_equal(const memory_resource& other) const noexcept;

Returns:

this == dynamic_cast<const unsynchronized_pool_resource*>(&other).

virtual bool synchronized_pool_resource::do_is_equal(const memory_resource& other) const noexcept;

Returns:

this == dynamic_cast<const synchronized_pool_resource*>(&other).

explicit monotonic_buffer_resource(memory_resource* upstream);monotonic_buffer_resource(size_t initial_size, memory_resource* upstream);

Requires:

upstream shall be the address of a valid memory resource. initial_size, if specified, shall be greater than zero.

Effects:

Sets upstream_rsrc to upstream and current_buffer to nullptr. If initial_size is specified, sets next_buffer_size to at least initial_size; otherwise sets next_buffer_size to an implementation-defined size.

monotonic_buffer_resource(void* buffer, size_t buffer_size, memory_resource* upstream);

Requires:

upstream shall be the address of a valid memory resource. buffer_size shall be no larger than the number of bytes in buffer.

Effects:

Sets upstream_rsrc to upstream, current_buffer to buffer, and next_buffer_size to initial_size (but not less than 1), then increases next_buffer_size by an implementation-defined growth factor (which need not be integral).

~monotonic_buffer_resource();

Effects:

Calls this->release().

void release();

Effects:

Calls upstream_rsrc->deallocate() as necessary to release all allocated memory.

[ Note: memory is released back to upstream_rsrc even if some blocks that were allocated from this have not been deallocated from this. — end note ]

memory_resource* upstream_resource() const;

Returns:

The value of upstream_rsrc.

void* do_allocate(size_t bytes, size_t alignment);

Returns:

A pointer to allocated storage (C++14 §3.7.4.2) with a size of at least bytes. The size and alignment of the allocated memory shall meet the requirements for a class derived from memory_resource (8.5).

Effects:

If the unused space in current_buffer can fit a block with the specified bytes and alignment, then allocate the return block from current_buffer; otherwise set current_buffer to upstream_rsrc->allocate(n, m), where n is not less than max(bytes, next_buffer_size) and m is not less than alignment, and increase next_buffer_size by an implementation-defined growth factor (which need not be integral), then allocate the return block from the newly-allocated current_buffer.

Throws:

Nothing unless upstream_rsrc->allocate() throws.

void do_deallocate(void* p, size_t bytes, size_t alignment);

Effects:

None

Throws:

Nothing

Remarks:

Memory used by this resource increases monotonically until its destruction.

bool do_is_equal(const memory_resource& other) const noexcept;

Returns:

this == dynamic_cast<const monotonic_buffer_resource*>(&other).