[func.wrap.copy.ctor] (original) (raw)

22 General utilities library [utilities]

22.10 Function objects [function.objects]

22.10.17 Polymorphic function wrappers [func.wrap]

22.10.17.5 Copyable wrapper [func.wrap.copy]

22.10.17.5.3 Constructors, assignments, and destructors [func.wrap.copy.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...>

copyable_function() noexcept; copyable_function(nullptr_t) noexcept;

Postconditions: *this has no target object.

copyable_function(const copyable_function& f);

Postconditions: *this has no target object if f had no target object.

Otherwise, the target object of *thisis a copy of the target object of f.

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

May throw bad_alloc.

copyable_function(copyable_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> copyable_function(F&& f);

Constraints:

• remove_cvref_t<F> is not the same type as copyable_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, and
• is_copy_constructible_v<VT> 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 copyable_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 copyable_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, and
• is_copy_constructible_v<VT> is true.

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 pointer or a specialization of reference_wrapper.

template<class T, class U, class... Args> explicit copyable_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, and
• is_copy_constructible_v<VT> is true.

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 pointer or a specialization of reference_wrapper.

copyable_function& operator=(const copyable_function& f);

Effects: Equivalent to: copyable_function(f).swap(*this);

copyable_function& operator=(copyable_function&& f);

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

copyable_function& operator=(nullptr_t) noexcept;

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

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

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

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