memory¶

`#include <hpx/memory/intrusive_ptr.hpp>`¶

template <typename T> template<> 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<U> const &b)¶

template <typename T, typename U> bool operator!=(intrusive_ptr<T> const &a, intrusive_ptr<U> 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<U> const &b)¶

template <typename T, typename U> bool operator!=(T *a, intrusive_ptr<U> 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<U> const &p)¶

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

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

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

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

template <typename T, typename U> intrusive_ptr<T> dynamic_pointer_cast(intrusive_ptr<U> &&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

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<U> const &rhs)¶

intrusive_ptr(intrusive_ptr const &rhs)¶

~intrusive_ptr()¶

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

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> intrusive_ptr(intrusive_ptr<U> &&rhs)¶

template <typename U> intrusive_ptr &operator=(intrusive_ptr<U> &&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)¶

T *get() const¶

T *detach()¶

T &operator*() const¶

T *operator->() const¶

operator bool() const¶

void swap(intrusive_ptr &rhs)¶

Private Types

template<> using this_type = intrusive_ptr¶

Private Members

T *px¶

Friends

friend hpx::memory::intrusive_ptr

namespace std

template <typename T> template<> 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¶

`#include <hpx/memory/serialization/intrusive_ptr.hpp>`¶

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 >))