[func.wrap.move] (original) (raw)

22 General utilities library [utilities]

22.10 Function objects [function.objects]

22.10.17 Polymorphic function wrappers [func.wrap]

22.10.17.4 Move-only wrapper [func.wrap.move]

22.10.17.4.1 General [func.wrap.move.general]

The header provides partial specializations of move_only_functionfor each combination of the possible replacements of the placeholders cv, ref, and noex where

• cv is either const or empty,
• ref is either &, &&, or empty, and
• noex is either true or false.

For each of the possible combinations of the placeholders mentioned above, there is a placeholder inv-quals defined as follows:

• If ref is empty, let inv-quals be cv&,
• otherwise, let inv-quals be cv ref.

22.10.17.4.2 Class template move_only_function [func.wrap.move.class]

namespace std { template<class R, class... ArgTypes> class move_only_function<R(ArgTypes...) cv _ref_ noexcept(_noex_)> { public: using result_type = R; move_only_function() noexcept; move_only_function(nullptr_t) noexcept; move_only_function(move_only_function&&) noexcept;template<class F> move_only_function(F&&);template<class T, class... Args> explicit move_only_function(in_place_type_t<T>, Args&&...);template<class T, class U, class... Args> explicit move_only_function(in_place_type_t<T>, initializer_list<U>, Args&&...); move_only_function& operator=(move_only_function&&); move_only_function& operator=(nullptr_t) noexcept;template<class F> move_only_function& operator=(F&&);~move_only_function();explicit operator bool() const noexcept; R operator()(ArgTypes...) cv ref noexcept(noex);void swap(move_only_function&) noexcept;friend void swap(move_only_function&, move_only_function&) noexcept;friend bool operator==(const move_only_function&, nullptr_t) noexcept;private: template<class VT> static constexpr bool is-callable-from = see below; };}

The move_only_function class template provides polymorphic wrappers that generalize the notion of a callable object ([func.def]).

These wrappers can store, move, and call arbitrary callable objects, given a call signature.

Recommended practice: Implementations should avoid the use of dynamically allocated memory for a small contained value.

[Note 1:

Such small-object optimization can only be applied to a type Tfor which is_nothrow_move_constructible_v<T> is true.

— _end note_]

22.10.17.4.3 Constructors, assignment, and destructor [func.wrap.move.ctor]

template<class VT> static constexpr bool _is-callable-from_ = _see below_;

If noex is true,is-callable-from<VT> is equal to:is_nothrow_invocable_r_v<R, VT cv _ref_, ArgTypes...> &&is_nothrow_invocable_r_v<R, VT _inv-quals_, ArgTypes...>

Otherwise, is-callable-from<VT> is equal to:is_invocable_r_v<R, VT cv _ref_, ArgTypes...> &&is_invocable_r_v<R, VT _inv-quals_, ArgTypes...>

move_only_function() noexcept; move_only_function(nullptr_t) noexcept;

Postconditions: *this has no target object.

move_only_function(move_only_function&& f) noexcept;

Postconditions: The target object of *this is the target object f had before construction, andf is in a valid state with an unspecified value.

template<class F> move_only_function(F&& f);

Constraints:

• remove_cvref_t<F> is not the same type as move_only_function, and
• remove_cvref_t<F> is not a specialization of in_place_type_t, and
• is-callable-from<VT> is true.

Mandates: is_constructible_v<VT, F> is true.

Postconditions: *this has no target object if any of the following hold:

• f is a null function pointer value, or
• f is a null member pointer value, or
• remove_cvref_t<F> is a specialization of the move_only_function class template, and f has no target object.

Otherwise, *this has a target object of type VTdirect-non-list-initialized with std​::​forward<F>(f).

Throws: Any exception thrown by the initialization of the target object.

May throw bad_alloc unless VT is a function pointer or a specialization of reference_wrapper.

template<class T, class... Args> explicit move_only_function(in_place_type_t<T>, Args&&... args);

Constraints:

• is_constructible_v<VT, Args...> is true, and
• is-callable-from<VT> is true.

Mandates: VT is the same type as T.

Postconditions: *this has a target object of type VTdirect-non-list-initialized with std​::​forward<Args>​(args)....

Throws: Any exception thrown by the initialization of the target object.

May throw bad_alloc unless VT is a function pointer or a specialization of reference_wrapper.

template<class T, class U, class... Args> explicit move_only_function(in_place_type_t<T>, initializer_list<U> ilist, Args&&... args);

Constraints:

• is_constructible_v<VT, initializer_list<U>&, Args...> istrue, and
• is-callable-from<VT> is true.

Mandates: VT is the same type as T.

Postconditions: *this has a target object of type VTdirect-non-list-initialized withilist, std​::​forward<Args>(args)....

Throws: Any exception thrown by the initialization of the target object.

May throw bad_alloc unless VT is a function pointer or a specialization of reference_wrapper.

move_only_function& operator=(move_only_function&& f);

Effects: Equivalent to: move_only_function(std​::​move(f)).swap(*this);

move_only_function& operator=(nullptr_t) noexcept;

Effects: Destroys the target object of *this, if any.

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

Effects: Equivalent to: move_only_function(std​::​forward<F>(f)).swap(*this);

Effects: Destroys the target object of *this, if any.

22.10.17.4.4 Invocation [func.wrap.move.inv]

explicit operator bool() const noexcept;

Returns: true if *this has a target object, otherwise false.

R operator()(ArgTypes... args) cv _ref_ noexcept(_noex_);

Preconditions: *this has a target object.

Effects: Equivalent to:return INVOKE<R>(static_cast<F _inv-quals_>(f), std::forward<ArgTypes>(args)...);where f is an lvalue designating the target object of *this andF is the type of f.

22.10.17.4.5 Utility [func.wrap.move.util]

void swap(move_only_function& other) noexcept;

Effects: Exchanges the target objects of *this and other.

friend void swap(move_only_function& f1, move_only_function& f2) noexcept;

Effects: Equivalent to f1.swap(f2).

friend bool operator==(const move_only_function& f, nullptr_t) noexcept;

Returns: true if f has no target object, otherwise false.