| //// |
| Copyright 2003-2005, 2013, 2017 Peter Dimov |
| |
| Distributed under the Boost Software License, Version 1.0. |
| |
| See accompanying file LICENSE_1_0.txt or copy at |
| http://www.boost.org/LICENSE_1_0.txt |
| //// |
| |
| [#intrusive_ptr] |
| # intrusive_ptr: Managing Objects with Embedded Counts |
| :toc: |
| :toc-title: |
| :idprefix: intrusive_ptr_ |
| |
| ## Description |
| |
| The `intrusive_ptr` class template stores a pointer to an object with an embedded reference count. |
| Every new `intrusive_ptr` instance increments the reference count by using an unqualified call to the |
| function `intrusive_ptr_add_ref`, passing it the pointer as an argument. Similarly, when an `intrusive_ptr` |
| is destroyed, it calls `intrusive_ptr_release`; this function is responsible for destroying the object when |
| its reference count drops to zero. The user is expected to provide suitable definitions of these two functions. |
| On compilers that support argument-dependent lookup, `intrusive_ptr_add_ref` and `intrusive_ptr_release` should |
| be defined in the namespace that corresponds to their parameter; otherwise, the definitions need to go in namespace |
| `boost`. The library provides a helper base class template `<<intrusive_ref_counter,intrusive_ref_counter>>` which |
| may help adding support for `intrusive_ptr` to user types. |
| |
| The class template is parameterized on `T`, the type of the object pointed to. `intrusive_ptr<T>` can be implicitly |
| converted to `intrusive_ptr<U>` whenever `T*` can be implicitly converted to `U*`. |
| |
| The main reasons to use `intrusive_ptr` are: |
| |
| * Some existing frameworks or OSes provide objects with embedded reference counts; |
| * The memory footprint of `intrusive_ptr` is the same as the corresponding raw pointer; |
| * `intrusive_ptr<T>` can be constructed from an arbitrary raw pointer of type `T*`. |
| |
| As a general rule, if it isn't obvious whether `intrusive_ptr` better fits your needs than `shared_ptr`, try a `shared_ptr`-based design first. |
| |
| ## Synopsis |
| |
| `intrusive_ptr` is defined in `<boost/smart_ptr/intrusive_ptr.hpp>`. |
| |
| ``` |
| namespace boost { |
| |
| template<class T> class intrusive_ptr { |
| public: |
| |
| typedef T element_type; |
| |
| intrusive_ptr() noexcept; |
| intrusive_ptr(T * p, bool add_ref = true); |
| |
| intrusive_ptr(intrusive_ptr const & r); |
| template<class Y> intrusive_ptr(intrusive_ptr<Y> const & r); |
| |
| intrusive_ptr(intrusive_ptr && r); |
| template<class Y> intrusive_ptr(intrusive_ptr<Y> && r); |
| |
| ~intrusive_ptr(); |
| |
| intrusive_ptr & operator=(intrusive_ptr const & r); |
| template<class Y> intrusive_ptr & operator=(intrusive_ptr<Y> const & r); |
| intrusive_ptr & operator=(T * r); |
| |
| intrusive_ptr & operator=(intrusive_ptr && r); |
| template<class Y> intrusive_ptr & operator=(intrusive_ptr<Y> && r); |
| |
| void reset(); |
| void reset(T * r); |
| void reset(T * r, bool add_ref); |
| |
| T & operator*() const noexcept; |
| T * operator->() const noexcept; |
| T * get() const noexcept; |
| T * detach() noexcept; |
| |
| explicit operator bool () const noexcept; |
| |
| void swap(intrusive_ptr & b) noexcept; |
| }; |
| |
| template<class T, class U> |
| bool operator==(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) noexcept; |
| |
| template<class T, class U> |
| bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) noexcept; |
| |
| template<class T, class U> |
| bool operator==(intrusive_ptr<T> const & a, U * b) noexcept; |
| |
| template<class T, class U> |
| bool operator!=(intrusive_ptr<T> const & a, U * b) noexcept; |
| |
| template<class T, class U> |
| bool operator==(T * a, intrusive_ptr<U> const & b) noexcept; |
| |
| template<class T, class U> |
| bool operator!=(T * a, intrusive_ptr<U> const & b) noexcept; |
| |
| template<class T> |
| bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b) noexcept; |
| |
| template<class T> void swap(intrusive_ptr<T> & a, intrusive_ptr<T> & b) noexcept; |
| |
| template<class T> T * get_pointer(intrusive_ptr<T> const & p) noexcept; |
| |
| template<class T, class U> |
| intrusive_ptr<T> static_pointer_cast(intrusive_ptr<U> const & r) noexcept; |
| |
| template<class T, class U> |
| intrusive_ptr<T> const_pointer_cast(intrusive_ptr<U> const & r) noexcept; |
| |
| template<class T, class U> |
| intrusive_ptr<T> dynamic_pointer_cast(intrusive_ptr<U> const & r) noexcept; |
| |
| template<class E, class T, class Y> |
| std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, |
| intrusive_ptr<Y> const & p); |
| } |
| ``` |
| |
| ## Members |
| |
| ### element_type |
| |
| ``` |
| typedef T element_type; |
| ``` |
| |
| Provides the type of the template parameter T. |
| |
| ### constructors |
| |
| ``` |
| intrusive_ptr() noexcept; |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Postconditions:: `get() == 0`. |
| |
| ``` |
| intrusive_ptr(T * p, bool add_ref = true); |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Effects:: `if(p != 0 && add_ref) intrusive_ptr_add_ref(p);`. |
| Postconditions:: `get() == p`. |
| |
| ``` |
| intrusive_ptr(intrusive_ptr const & r); |
| ``` |
| ``` |
| template<class Y> intrusive_ptr(intrusive_ptr<Y> const & r); |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Effects:: `T * p = r.get(); if(p != 0) intrusive_ptr_add_ref(p);`. |
| Postconditions:: `get() == r.get()`. |
| |
| ``` |
| intrusive_ptr(intrusive_ptr && r); |
| ``` |
| ``` |
| template<class Y> intrusive_ptr(intrusive_ptr<Y> && r); |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Postconditions:: |
| `get()` equals the old value of `r.get()`. `r.get() == 0`. |
| |
| ### destructor |
| |
| ``` |
| ~intrusive_ptr(); |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Effects:: |
| `if(get() != 0) intrusive_ptr_release(get());`. |
| |
| ### assignment |
| |
| ``` |
| intrusive_ptr & operator=(intrusive_ptr const & r); |
| ``` |
| ``` |
| template<class Y> intrusive_ptr & operator=(intrusive_ptr<Y> const & r); |
| ``` |
| ``` |
| intrusive_ptr & operator=(T * r); |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Effects:: Equivalent to `intrusive_ptr(r).swap(*this)`. |
| Returns:: `*this`. |
| |
| ``` |
| intrusive_ptr & operator=(intrusive_ptr && r); |
| ``` |
| ``` |
| template<class Y> intrusive_ptr & operator=(intrusive_ptr<Y> && r); |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Effects:: Equivalent to `intrusive_ptr(std::move(r)).swap(*this)`. |
| Returns:: `*this`. |
| |
| ### reset |
| |
| ``` |
| void reset(); |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Effects:: Equivalent to `intrusive_ptr().swap(*this)`. |
| |
| ``` |
| void reset(T * r); |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Effects:: Equivalent to `intrusive_ptr(r).swap(*this)`. |
| |
| ``` |
| void reset(T * r, bool add_ref); |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Effects:: |
| Equivalent to `intrusive_ptr(r, add_ref).swap(*this)`. |
| |
| ### indirection |
| |
| ``` |
| T & operator*() const noexcept; |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Requirements:: `get() != 0`. |
| Returns:: `*get()`. |
| |
| ``` |
| T * operator->() const noexcept; |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Requirements:: `get() != 0`. |
| Returns:: `get()`. |
| |
| ### get |
| |
| ``` |
| T * get() const noexcept; |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Returns:: |
| the stored pointer. |
| |
| ### detach |
| |
| ``` |
| T * detach() noexcept; |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Returns:: the stored pointer. |
| Postconditions:: `get() == 0`. |
| |
| NOTE: The returned pointer has an elevated reference count. This allows conversion of an `intrusive_ptr` |
| back to a raw pointer, without the performance overhead of acquiring and dropping an extra reference. |
| It can be viewed as the complement of the non-reference-incrementing constructor. |
| |
| CAUTION: Using `detach` escapes the safety of automatic reference counting provided by `intrusive_ptr`. |
| It should by used only where strictly necessary (such as when interfacing to an existing API), and when |
| the implications are thoroughly understood. |
| |
| ### conversions |
| |
| ``` |
| explicit operator bool () const noexcept; |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Returns:: `get() != 0`. |
| |
| NOTE: This conversion operator allows `intrusive_ptr` objects to be used in boolean contexts, |
| like `if (p && p\->valid()) {}`. |
| |
| NOTE: On C++03 compilers, the return value is of an unspecified type. |
| |
| ### swap |
| |
| ``` |
| void swap(intrusive_ptr & b) noexcept; |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Effects:: |
| Exchanges the contents of the two smart pointers. |
| |
| ## Free Functions |
| |
| ### comparison |
| |
| ``` |
| template<class T, class U> |
| bool operator==(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) noexcept; |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Returns:: `a.get() == b.get()`. |
| |
| ``` |
| template<class T, class U> |
| bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) noexcept; |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Returns:: `a.get() != b.get()`. |
| |
| ``` |
| template<class T, class U> |
| bool operator==(intrusive_ptr<T> const & a, U * b) noexcept; |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Returns:: `a.get() == b`. |
| |
| ``` |
| template<class T, class U> |
| bool operator!=(intrusive_ptr<T> const & a, U * b) noexcept; |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Returns:: `a.get() != b`. |
| |
| ``` |
| template<class T, class U> |
| bool operator==(T * a, intrusive_ptr<U> const & b) noexcept; |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Returns:: `a == b.get()`. |
| |
| ``` |
| template<class T, class U> |
| bool operator!=(T * a, intrusive_ptr<U> const & b) noexcept; |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Returns:: `a != b.get()`. |
| |
| ``` |
| template<class T> |
| bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b) noexcept; |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Returns:: `std::less<T *>()(a.get(), b.get())`. |
| |
| NOTE: Allows `intrusive_ptr` objects to be used as keys in associative containers. |
| |
| ### swap |
| |
| ``` |
| template<class T> void swap(intrusive_ptr<T> & a, intrusive_ptr<T> & b) noexcept; |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Effects:: |
| Equivalent to `a.swap(b)`. |
| |
| ### get_pointer |
| |
| ``` |
| template<class T> T * get_pointer(intrusive_ptr<T> const & p) noexcept; |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Returns:: `p.get()`. |
| |
| NOTE: Provided as an aid to generic programming. Used by `mem_fn`. |
| |
| ### static_pointer_cast |
| |
| ``` |
| template<class T, class U> |
| intrusive_ptr<T> static_pointer_cast(intrusive_ptr<U> const & r) noexcept; |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Returns:: |
| `intrusive_ptr<T>(static_cast<T*>(r.get()))`. |
| |
| ### const_pointer_cast |
| |
| ``` |
| template<class T, class U> |
| intrusive_ptr<T> const_pointer_cast(intrusive_ptr<U> const & r) noexcept; |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Returns:: |
| `intrusive_ptr<T>(const_cast<T*>(r.get()))`. |
| |
| ### dynamic_pointer_cast |
| |
| ``` |
| template<class T, class U> |
| intrusive_ptr<T> dynamic_pointer_cast(intrusive_ptr<U> const & r) noexcept; |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Returns:: |
| `intrusive_ptr<T>(dynamic_cast<T*>(r.get()))`. |
| |
| ### operator<< |
| |
| ``` |
| template<class E, class T, class Y> |
| std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, |
| intrusive_ptr<Y> const & p); |
| ``` |
| |
| [none] |
| * {blank} |
| + |
| Effects:: `os << p.get();`. |
| Returns:: `os`. |