Linux Manuals session 3

std::experimental::is_detected,std::experimental::detected_t,std::experimental::detected_or – std::experimental::is_detected,std::experimental::detected_t,std::experimental::detected_or Synopsis Defined in header <experimental/type_traits> template< template<class…> class Op, class… Args > (library fundamentals TS v2) using is_detected = /* see below */; template< template<class…> class Op, class… Args > (library fundamentals TS v2) using detected_t = /* see below */; template< class Default, template<class…> class Op, class… Args > (library fundamentals…

std::experimental::is_detected,std::experimental::detected_t, – std::experimental::is_detected,std::experimental::detected_t, Synopsis Defined in header <experimental/type_traits> template< template<class…> class Op, class… Args > (library fundamentals TS v2) using is_detected = /* see below */; template< template<class…> class Op, class… Args > (library fundamentals TS v2) using detected_t = /* see below */; template< class Default, template<class…> class Op, class… Args > (library fundamentals…

std::experimental::invocation_type,std::experimental::raw_invocation_type – std::experimental::invocation_type,std::experimental::raw_invocation_type Synopsis Defined in header<experimental / type_traits> template <class> struct raw_invocation_type; // undefined (1)(library fundamentals TS) template <class Fn, class… ArgTypes> struct raw_invocation_type<Fn(ArgTypes…)>; template <class> struct invocation_type; // undefined (2)(library fundamentals TS) template <class Fn, class… ArgTypes> struct invocation_type<Fn(ArgTypes…)>; Computes the invocation parameters when Fn is called with the arguments ArgTypes…, as in…

std::experimental::in_place_t – std::experimental::in_place_t Synopsis Defined in header <experimental/optional> struct in_place_t {}; (library fundamentals TS) std::experimental::in_place_t is an empty class type used to disambiguate the overloads of constructors and member functions of that take arguments (possibly a parameter pack) for in-place construction of some value. See also in_place_ in_place_type_ in_place_index_ in-place construction tag in_place_t_ (class template)…

std::experimental::in_place – std::experimental::in_place Synopsis Defined in header <experimental/optional> constexpr in_place_t in_place{}; (library fundamentals TS) std::experimental::in_place is a constant of type std::experimental::in_place_t that is used to disambiguate the overloads of constructors and member functions of that take arguments (possibly a parameter pack) for in-place construction of some value. See also in_place_ in_place_type_ in_place_index_ in-place construction tag…

std::experimental::get_underlying – std::experimental::get_underlying Synopsis template <class T> (library fundamentals TS v2) constexpr T &get_underlying(propagate_const<T> &pt) noexcept; template <class T> (library fundamentals TS v2) constexpr const T &get_underlying(const propagate_const<T> &pt) noexcept; Retrieves a reference to the pointer-like object stored in a propagate_const. Parameters pt – a propagate_const object Return value A reference to the pointer-like object…

std::experimental::gcd – std::experimental::gcd Synopsis Defined in header <experimental/numeric> template< class M, class N> (library fundamentals TS v2) constexpr std::common_type_t<M, N> gcd(M m, N n); Computes the greatest common divisor of the integers m and n. Parameters m, n – integer values Return value If both m and n are zero, returns zero. Otherwise, returns the…

std::experimental::future<T>::then – std::experimental::future<T>::then Synopsis template < class F > future</* see below */> then(F&& func) ; Attach the continuation func to *this. The behavior is undefined if *this has no associated shared state (i.e., valid() == false). Creates a shared state associated with the future object to be returned, and a copy fd of func…

std::experimental::future<T>::operator= – std::experimental::future<T>::operator= Synopsis std::experimental::future<T> &operator=(std::experimental::future<T> &&other) noexcept; (1) std::experimental::future<T> & operator=(const std::experimental::future<T> &other) = delete; (2) Assigns the contents of another future object. 1) Releases any shared state and move-assigns the contents of other to *this. After the assignment, other.valid() == false and this->valid() will yield the same value as other.valid() before the assignment….

std::experimental::future<T>::is_ready – std::experimental::future<T>::is_ready Synopsis bool is_ready() const; Checks if the associated shared state is ready. The behavior is undefined if valid() is false. Parameters (none) Return value true if the associated shared state is ready, otherwise false. Example  This section is incomplete  Reason: no example See also       checks if the future has a shared state…

std::experimental::future<T>::future – std::experimental::future<T>::future Synopsis future() noexcept; (1) future(std::experimental::future<T> &&f) noexcept; (2) future(const std::experimental::future<T> &) = delete; (3) future(std::experimental::future<std::experimental::future<T>> &&other) noexcept; (4) 1) Default constructor. Constructs an empty future object that does not refer to a shared state. 2) Constructs a future object, transferring the shared state held by f, if any. After construction, f.valid() is…

std::experimental::future – std::experimental::future Synopsis Defined in header <experimental/future> template< class T > class future; (1) (concurrency TS) template< class T > class future<T&>; (2) (concurrency TS) template<> class future<void>; (3) (concurrency TS) The class template std::experimental::future extends std::future with the following operations: * an unwrapping constructor from future<future<T>>; * a member function is_ready to query…

std::experimental::function<R(Args…)>::swap – std::experimental::function<R(Args…)>::swap Synopsis void swap(function &other); (library fundamentals TS) Exchanges the stored callable objects of *this and other. The allocators of *this and other are not exchanged. The behavior is undefined if *this->get_memory_resource() != *other.get_memory_resource(). Parameters other – function wrapper to exchange the stored callable object with Return value (none)

std::experimental::function<R(Args…)>::operator= – std::experimental::function<R(Args…)>::operator= Synopsis function &operator=(const function &other); (1)(library fundamentals TS) function & operator=(function &&other); (2)(library fundamentals TS) function & operator=(std::nullptr_t) noexcept; (3)(library fundamentals TS) template <class F> (4)(library fundamentals TS) function & operator=(F &&f); template <class F> (5)(library fundamentals TS) function & operator=(std::reference_wrapper<F> f); Assigns a new target to std::experimental::function.In the description below, let…

std::experimental::function<R(Args…)>::get_memory_resource – std::experimental::function<R(Args…)>::get_memory_resource Synopsis std::experimental::pmr::memory_resource* get_memory_resource() const noexcept; (library fundamentals TS) Returns a pointer to the memory resource used by this object to allocate memory. Parameters (none) Return value A pointer to the memory resource used by this object to allocate memory. See also               constructs a new std::experimental::function instance constructor (public member function)

std::experimental::function<R(Args…)>::function – std::experimental::function<R(Args…)>::function Synopsis function() noexcept; (1)(library fundamentals TS) function(std::nullptr_t) noexcept; (2)(library fundamentals TS) function(const function &other); (3)(library fundamentals TS) function(function &&other); (4)(library fundamentals TS) template <class F> (5)(library fundamentals TS) function(F f); template <class Alloc> (6)(library fundamentals TS) function(std::allocator_arg_t, const Alloc &alloc) noexcept; template <class Alloc> function(std::allocator_arg_t, const Alloc &alloc, (7)(library fundamentals TS) std::nullptr_t)…

std::experimental::function – std::experimental::function Synopsis Defined in header <experimental/functional> template< class > (library fundamentals TS) class function; /* undefined */ template< class R, class… Args > (library fundamentals TS) class function<R(Args…)> std::experimental::function is a modified version of std::function with support for type-erased allocators. Member types Type Definition allocator_type std::experimental::erased_type Member functions                     constructs a new std::experimental::function instance…

std::experimental::flex_barrier::~flex_barrier – std::experimental::flex_barrier::~flex_barrier Synopsis ~flex_barrier(); (concurrency TS) Destroys the flex_barrier. The behavior is undefined if a thread is blocked at the synchronization point.

std::experimental::flex_barrier::arrive_and_wait – std::experimental::flex_barrier::arrive_and_wait Synopsis void arrive_and_wait(); (concurrency TS) Blocks and arrives at the flex_barrier’s synchronization point. The behavior is undefined if the calling thread is not in the set of participating threads of this flex_barrier. Calls to arrive_and_wait synchronizes with the start of the completion phase of the flex_barrier. The completion of the completion phase…

std::experimental::flex_barrier::arrive_and_drop – std::experimental::flex_barrier::arrive_and_drop Synopsis void arrive_and_drop(); (concurrency TS) Arrive at the flex_barrier’s synchronization point and remove the current thread from the set of participating threads. It is unspecified whether this function blocks until the completion phase has ended. If the function blocks, the calling thread may be chosen to execute the completion phase. The behavior…