Linux Manuals session 3

std::experimental::atomic_weak_ptr<T>::exchange – std::experimental::atomic_weak_ptr<T>::exchange Synopsis weak_ptr<T> exchange( weak_ptr<T> desired, std::memory_order order = std::memory_order_seq_cst ) noexcept; Atomically replaces the underlying weak_ptr with desired. The operation is a read-modify-write operation. Memory is affected according to the value of order. Parameters desired – value to assign order – memory order constraints to enforce Return value The value of the…

std::experimental::atomic_weak_ptr<T>::compare_exchange_strong,std::experimental::atomic_weak_ptr<T>::compare_exchange_weak – std::experimental::atomic_weak_ptr<T>::compare_exchange_strong,std::experimental::atomic_weak_ptr<T>::compare_exchange_weak Synopsis bool compare_exchange_weak(std::weak_ptr<T> &expected, const std::weak_ptr<T> &desired, (1) std::memory_order success, std::memory_order failure) noexcept; bool compare_exchange_weak(std::weak_ptr<T> &expected, std::weak_ptr<T> &&desired, (2) std::memory_order success, std::memory_order failure) noexcept; bool compare_exchange_weak(std::weak_ptr<T> &expected, const std::weak_ptr<T> &desired, (3) std::memory_order order = std::memory_order_seq_cst) noexcept; bool compare_exchange_weak(std::weak_ptr<T> &expected, std::weak_ptr<T> &&desired, (4) std::memory_order order = std::memory_order_seq_cst) noexcept; bool compare_exchange_strong(std::weak_ptr<T> &expected, const std::weak_ptr<T>…

std::experimental::atomic_weak_ptr<T>::atomic_weak_ptr – std::experimental::atomic_weak_ptr<T>::atomic_weak_ptr Synopsis constexpr atomic_weak_ptr() noexcept; (1) constexpr atomic_weak_ptr(weak_ptr<T> desired) noexcept; (2) atomic_weak_ptr(const atomic_weak_ptr &) = delete; (3) Constructs a new atomic_weak_ptr object. 1) The default constructor initializes the object to an empty state. 2) Initializes the underlying weak_ptr<T> with desired. The initialization is not atomic. 3) Atomic variables are not CopyConstructible. Parameters desired…

std::experimental::atomic_weak_ptr – std::experimental::atomic_weak_ptr Synopsis Defined in header <experimental/atomic> template < class T > (concurrency TS) class atomic_weak_ptr; The class template atomic_weak_ptr provides thread-safe atomic pointer operations over a std::weak_ptr. Member functions                         constructs an atomic_weak_ptr object constructor (public member function)                         stores a value into an atomic_weak_ptr object operator= (public member function)                         checks if the atomic_weak_ptr object…

std::experimental::atomic_shared_ptr<T>::store – std::experimental::atomic_shared_ptr<T>::store Synopsis void store(shared_ptr<T> desired, std::memory_order order = std::memory_order_seq_cst) noexcept; Atomically replaces the current value with desired. Memory is affected according to the value of order. order must be one of std::memory_order_relaxed, std::memory_order_release or std::memory_order_seq_cst. Otherwise the behavior is undefined. Parameters desired – the shared_ptr to store into the atomic variable order –…

std::experimental::atomic_shared_ptr<T>::operatorshared_ptr<T> – std::experimental::atomic_shared_ptr<T>::operatorshared_ptr<T> Synopsis operator shared_ptr<T>() const noexcept; Atomically loads and returns the current value of the atomic_shared_ptr. Equivalent to load(). Parameters (none) Return value The current value of the atomic_shared_ptr. Remarks All associated use_count increments are guaranteed to be performed as part of the atomic operation. See also      atomically obtains the value of the…

std::experimental::atomic_shared_ptr<T>::operator= – std::experimental::atomic_shared_ptr<T>::operator= Synopsis void operator=(shared_ptr<T> desired) noexcept; (1) void operator=(const atomic_shared_ptr &) = delete; (2) 1) Atomically assigns a value desired to the atomic variable. Equivalent to store(desired). 2) Atomic variables are not CopyAssignable. Parameters desired – value to assign Notes Unlike most assignment operators, the assignment operators for atomic_shared_ptr returns void. Remarks All…

std::experimental::atomic_shared_ptr<T>::load – std::experimental::atomic_shared_ptr<T>::load Synopsis shared_ptr<T> load(std::memory_order order = std::memory_order_seq_cst) const noexcept; Atomically loads and returns the current value of the atomic_shared_ptr. Memory is affected according to the value of order. order must be one of std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire or std::memory_order_seq_cst. Otherwise the behavior is undefined. Parameters order – memory order constraints to enforce Remarks All…

std::experimental::atomic_shared_ptr<T>::is_lock_free – std::experimental::atomic_shared_ptr<T>::is_lock_free Synopsis bool is_lock_free() const noexcept; Checks whether the atomic operations on all objects of this type are lock-free. Parameters (none) Return value true if the atomic operations on the objects of this type are lock-free, false otherwise. See also std::atomic_is_lock_free(std::shared_ptr) std::atomic_load(std::shared_ptr) std::atomic_load_explicit(std::shared_ptr) std::atomic_store(std::shared_ptr) std::atomic_store_explicit(std::shared_ptr) std::atomic_exchange(std::shared_ptr) specializes atomic operations for std::shared_ptr std::atomic_exchange_explicit(std::shared_ptr) (function…

std::experimental::atomic_shared_ptr<T>::exchange – std::experimental::atomic_shared_ptr<T>::exchange Synopsis shared_ptr<T> exchange( shared_ptr<T> desired, std::memory_order order = std::memory_order_seq_cst ) noexcept; Atomically replaces the underlying shared_ptr with desired. The operation is a read-modify-write operation. Memory is affected according to the value of order. Parameters desired – value to assign order – memory order constraints to enforce Return value The value of the…

std::experimental::atomic_shared_ptr<T>::compare_exchange_strong,std::experimental::atomic_shared_ptr<T>::compare_exchange_weak – std::experimental::atomic_shared_ptr<T>::compare_exchange_strong,std::experimental::atomic_shared_ptr<T>::compare_exchange_weak Synopsis bool compare_exchange_weak(std::shared_ptr<T> &expected, const std::shared_ptr<T> &desired, (1) std::memory_order success, std::memory_order failure) noexcept; bool compare_exchange_weak(std::shared_ptr<T> &expected, std::shared_ptr<T> &&desired, (2) std::memory_order success, std::memory_order failure) noexcept; bool compare_exchange_weak(std::shared_ptr<T> &expected, const std::shared_ptr<T> &desired, (3) std::memory_order order = std::memory_order_seq_cst) noexcept; bool compare_exchange_weak(std::shared_ptr<T> &expected, std::shared_ptr<T> &&desired, (4) std::memory_order order = std::memory_order_seq_cst) noexcept; bool compare_exchange_strong(std::shared_ptr<T> &expected, const std::shared_ptr<T>…

std::experimental::atomic_shared_ptr<T>::atomic_shared_ptr – std::experimental::atomic_shared_ptr<T>::atomic_shared_ptr Synopsis constexpr atomic_shared_ptr() noexcept; (1) constexpr atomic_shared_ptr(shared_ptr<T> desired) noexcept; (2) atomic_shared_ptr(const atomic_shared_ptr &) = delete; (3) Constructs a new atomic_shared_ptr object. 1) The default constructor initializes the object to an empty state. 2) Initializes the underlying shared_ptr<T> with desired. The initialization is not atomic. 3) Atomic variables are not CopyConstructible. Parameters desired…

std::experimental::atomic_shared_ptr – std::experimental::atomic_shared_ptr Synopsis Defined in header <experimental/atomic> template < class T > (concurrency TS) class atomic_shared_ptr; The class template atomic_shared_ptr provides thread-safe atomic pointer operations over a std::shared_ptr. It provides a better alternative to the_non-member_shared_ptr_atomic_access_functions. Member functions                         constructs an atomic_shared_ptr object constructor (public member function)                         stores a value into an atomic_shared_ptr object operator= (public…

std::experimental::apply – std::experimental::apply Synopsis Defined in header <experimental/tuple> template <class F, class Tuple> (library fundamentals TS) constexpr decltype(auto) apply(F&& f, Tuple&& t); Invoke the Callable object f with a tuple of arguments. Parameters f – Callable object to be invoked t – tuple whose elements to be used as arguments to f Return value What…

std::experimental::any_cast – std::experimental::any_cast Synopsis template <class ValueType> (1)(library fundamentals TS) ValueType any_cast(const any &operand); template <class ValueType> (2)(library fundamentals TS) ValueType any_cast(any &operand); template <class ValueType> (3)(library fundamentals TS) ValueType any_cast(any &&operand); template <class ValueType> (4)(library fundamentals TS) const ValueType *any_cast(const any *operand) noexcept; template <class ValueType> (5)(library fundamentals TS) ValueType *any_cast(any *operand) noexcept; Performs…

std::experimental::any::type – std::experimental::any::type Synopsis const type_info &type() const noexcept; (library fundamentals TS) Queries the contained type. Parameters (none) Return value The typeid of the contained value if instance is non-empty, otherwise typeid(void).

std::experimental::any::swap – std::experimental::any::swap Synopsis void swap(any &other) noexcept; (library fundamentals TS) Swaps the content of two any objects. Parameters other – object to swap with Return value (none)

std::experimental::any::operator= – std::experimental::any::operator= Synopsis any &operator=(const any &rhs); (1)(library fundamentals TS) any & operator=(any &&rhs) noexcept; (2)(library fundamentals TS) template <typename ValueType> (3)(library fundamentals TS) any & operator=(ValueType &&rhs); Assigns contents to the contained value. 1) Assigns by copying the state of rhs, as if by any(rhs).swap(*this). 2) Assigns by moving the state of rhs,…

std::experimental::any::empty – std::experimental::any::empty Synopsis bool empty() const noexcept; (library fundamentals TS) Checks whether the object contains a value. Parameters (none) Return value true if instance is empty, otherwise false.

std::experimental::any::clear – std::experimental::any::clear Synopsis void clear() noexcept; (library fundamentals TS) If not empty, destroys the contained object. Parameters (none) Return value (none)