memory¶

The contents of this module can be included with the header hpx/modules/memory.hpp. These headers may be used by user-code but are not guaranteed stable (neither header location nor contents). You are using these at your own risk. If you wish to use non-public functionality from a module we strongly suggest only including the module header hpx/modules/memory.hpp, not the particular header in which the functionality you would like to use is defined. See Public API for a list of names that are part of the public HPX API.

template<typename T> struct hash<hpx::memory::intrusive_ptr<T>>¶

Public Types

template<> using result_type = std::size_t¶

Public Functions

result_type operator()(hpx::memory::intrusive_ptr<T> const &p) const¶

namespace hpx

namespace memory¶

Functions

template<typename T, typename U> bool operator==(intrusive_ptr<T> const &a, intrusive_ptr const &b)¶

template<typename T, typename U> bool operator!=(intrusive_ptr<T> const &a, intrusive_ptr const &b)¶

template<typename T, typename U> bool operator==(intrusive_ptr<T> const &a, U *b)¶

template<typename T, typename U> bool operator!=(intrusive_ptr<T> const &a, U *b)¶

template<typename T, typename U> bool operator==(T *a, intrusive_ptr const &b)¶

template<typename T, typename U> bool operator!=(T *a, intrusive_ptr const &b)¶

template<typename T> bool operator==(intrusive_ptr<T> const &p, std::nullptr_t)¶

template<typename T> bool operator==(std::nullptr_t, intrusive_ptr<T> const &p)¶

template<typename T> bool operator!=(intrusive_ptr<T> const &p, std::nullptr_t)¶

template<typename T> bool operator!=(std::nullptr_t, intrusive_ptr<T> const &p)¶

template<typename T> bool operator<(intrusive_ptr<T> const &a, intrusive_ptr<T> const &b)¶

template<typename T> void swap(intrusive_ptr<T> &lhs, intrusive_ptr<T> &rhs)¶

template<typename T> T *get_pointer(intrusive_ptr<T> const &p)¶

template<typename T, typename U> intrusive_ptr<T> static_pointer_cast(intrusive_ptr const &p)¶

template<typename T, typename U> intrusive_ptr<T> const_pointer_cast(intrusive_ptr const &p)¶

template<typename T, typename U> intrusive_ptr<T> dynamic_pointer_cast(intrusive_ptr const &p)¶

template<typename T, typename U> intrusive_ptr<T> static_pointer_cast(intrusive_ptr &&p)¶

template<typename T, typename U> intrusive_ptr<T> const_pointer_cast(intrusive_ptr &&p)¶

template<typename T, typename U> intrusive_ptr<T> dynamic_pointer_cast(intrusive_ptr &&p)¶

template<typename Y> std::ostream &operator<<(std::ostream &os, intrusive_ptr<Y> const &p)¶

template<typename T> class intrusive_ptr¶

Public Types

template<> using element_type = T¶

Public Functions

constexpr intrusive_ptr()¶

intrusive_ptr(T *p, bool add_ref = true)¶

template<typename U, typename Enable = typename std::enable_if<memory::detail::sp_convertible<U, T>::value>::type> intrusive_ptr(intrusive_ptr const &rhs)¶

intrusive_ptr(intrusive_ptr const &rhs)¶

~intrusive_ptr()¶

template<typename U> intrusive_ptr &operator=(intrusive_ptr const &rhs)¶

constexpr intrusive_ptr(intrusive_ptr &&rhs)¶

intrusive_ptr &operator=(intrusive_ptr &&rhs)¶

template<typename U, typename Enable = typename std::enable_if<memory::detail::sp_convertible<U, T>::value>::type> constexpr intrusive_ptr(intrusive_ptr &&rhs)¶

template<typename U> intrusive_ptr &operator=(intrusive_ptr &&rhs)¶

intrusive_ptr &operator=(intrusive_ptr const &rhs)¶

intrusive_ptr &operator=(T *rhs)¶

void reset()¶

void reset(T *rhs)¶

void reset(T *rhs, bool add_ref)¶

constexpr T *get() const¶

constexpr T *detach()¶

T &operator*() const¶

T *operator->() const¶

constexpr operator bool() const¶

constexpr void swap(intrusive_ptr &rhs)¶

Private Types

template<> using this_type = intrusive_ptr¶

Private Members

T *px = nullptr¶

Friends

friend hpx::memory::intrusive_ptr

namespace std

template<typename T> struct hash<hpx::memory::intrusive_ptr<T>>

Public Types

template<> using result_type = std::size_t

Public Functions

result_type operator()(hpx::memory::intrusive_ptr<T> const &p) const

namespace hpx

namespace serialization

Functions

template<typename T> void load(input_archive &ar, hpx::intrusive_ptr<T> &ptr, unsigned)¶

template<typename T> void save(output_archive &ar, hpx::intrusive_ptr<T> const &ptr, unsigned)¶

hpx::serialization::HPX_SERIALIZATION_SPLIT_FREE_TEMPLATE((template< typename T >), ( hpx::intrusive_ptr < T >))