////////////////////////////////////////////////////////////////////////////// // // This file is the adaptation for Interprocess of boost/intrusive_ptr.hpp // // (C) Copyright Peter Dimov 2001, 2002 // (C) Copyright Ion Gaztanaga 2006-2012. 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) // // See http://www.boost.org/libs/interprocess for documentation. // ////////////////////////////////////////////////////////////////////////////// #ifndef BOOST_INTERPROCESS_INTRUSIVE_PTR_HPP_INCLUDED #define BOOST_INTERPROCESS_INTRUSIVE_PTR_HPP_INCLUDED #ifndef BOOST_CONFIG_HPP # include <boost/config.hpp> #endif # #if defined(BOOST_HAS_PRAGMA_ONCE) # pragma once #endif //!\file //!Describes an intrusive ownership pointer. #include <boost/interprocess/detail/config_begin.hpp> #include <boost/interprocess/detail/workaround.hpp> #include <boost/assert.hpp> #include <boost/interprocess/detail/utilities.hpp> #include <boost/intrusive/pointer_traits.hpp> #include <boost/move/adl_move_swap.hpp> #include <boost/move/core.hpp> #include <iosfwd> // for std::basic_ostream #include <boost/intrusive/detail/minimal_less_equal_header.hpp> //std::less namespace boost { namespace interprocess { //!The intrusive_ptr class template stores a pointer to an object //!with an embedded reference count. intrusive_ptr is parameterized on //!T (the type of the object pointed to) and VoidPointer(a void pointer type //!that defines the type of pointer that intrusive_ptr will store). //!intrusive_ptr<T, void *> defines a class with a T* member whereas //!intrusive_ptr<T, offset_ptr<void> > defines a class with a offset_ptr<T> member. //!Relies on unqualified calls to: //! //! void intrusive_ptr_add_ref(T * p) BOOST_NOEXCEPT; //! void intrusive_ptr_release(T * p) BOOST_NOEXCEPT; //! //! with (p != 0) //! //!The object is responsible for destroying itself. template<class T, class VoidPointer> class intrusive_ptr { public: //!Provides the type of the internal stored pointer. typedef typename boost::intrusive:: pointer_traits<VoidPointer>::template rebind_pointer<T>::type pointer; //!Provides the type of the stored pointer. typedef T element_type; #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED) private: typedef VoidPointer VP; typedef intrusive_ptr this_type; typedef pointer this_type::*unspecified_bool_type; #endif //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED BOOST_COPYABLE_AND_MOVABLE(intrusive_ptr) public: //!Constructor. Initializes internal pointer to 0. //!Does not throw intrusive_ptr() BOOST_NOEXCEPT : m_ptr(0) {} //!Constructor. Copies pointer and if "p" is not zero and //!"add_ref" is true calls intrusive_ptr_add_ref(to_raw_pointer(p)). //!Does not throw intrusive_ptr(const pointer &p, bool add_ref = true) BOOST_NOEXCEPT : m_ptr(p) { if(m_ptr != 0 && add_ref) intrusive_ptr_add_ref(ipcdetail::to_raw_pointer(m_ptr)); } //!Copy constructor. Copies the internal pointer and if "p" is not //!zero calls intrusive_ptr_add_ref(to_raw_pointer(p)). Does not throw intrusive_ptr(intrusive_ptr const & rhs) BOOST_NOEXCEPT : m_ptr(rhs.m_ptr) { if(m_ptr != 0) intrusive_ptr_add_ref(ipcdetail::to_raw_pointer(m_ptr)); } //!Move constructor. Moves the internal pointer. Does not throw intrusive_ptr(BOOST_RV_REF(intrusive_ptr) rhs) BOOST_NOEXCEPT : m_ptr(rhs.m_ptr) { rhs.m_ptr = 0; } //!Constructor from related. Copies the internal pointer and if "p" is not //!zero calls intrusive_ptr_add_ref(to_raw_pointer(p)). Does not throw template<class U> intrusive_ptr(intrusive_ptr<U, VP> const & rhs) BOOST_NOEXCEPT : m_ptr(rhs.get()) { if(m_ptr != 0) intrusive_ptr_add_ref(ipcdetail::to_raw_pointer(m_ptr)); } //!Destructor. Calls reset(). Does not throw ~intrusive_ptr() { reset(); } //!Assignment operator. Equivalent to intrusive_ptr(r).swap(*this). //!Does not throw intrusive_ptr & operator=(BOOST_COPY_ASSIGN_REF(intrusive_ptr) rhs) BOOST_NOEXCEPT { this_type(rhs).swap(*this); return *this; } //!Move Assignment operator //!Does not throw intrusive_ptr & operator=(BOOST_RV_REF(intrusive_ptr) rhs) BOOST_NOEXCEPT { rhs.swap(*this); rhs.reset(); return *this; } //!Assignment from related. Equivalent to intrusive_ptr(r).swap(*this). //!Does not throw template<class U> intrusive_ptr & operator=(intrusive_ptr<U, VP> const & rhs) BOOST_NOEXCEPT { this_type(rhs).swap(*this); return *this; } //!Assignment from pointer. Equivalent to intrusive_ptr(r).swap(*this). //!Does not throw intrusive_ptr & operator=(pointer rhs) BOOST_NOEXCEPT { this_type(rhs).swap(*this); return *this; } //!Release internal pointer and set it to 0. If internal pointer is not 0, calls //!intrusive_ptr_release(to_raw_pointer(m_ptr)). Does not throw void reset() BOOST_NOEXCEPT { if(m_ptr != 0) { pointer ptr = m_ptr; m_ptr = 0; intrusive_ptr_release(ipcdetail::to_raw_pointer(ptr)); } } //!Returns a reference to the internal pointer. //!Does not throw pointer &get() BOOST_NOEXCEPT { return m_ptr; } //!Returns a reference to the internal pointer. //!Does not throw const pointer &get() const BOOST_NOEXCEPT { return m_ptr; } //!Returns *get(). //!Does not throw T & operator*() const BOOST_NOEXCEPT { return *m_ptr; } //!Returns *get(). //!Does not throw const pointer &operator->() const BOOST_NOEXCEPT { return m_ptr; } //!Returns get(). //!Does not throw pointer &operator->() BOOST_NOEXCEPT { return m_ptr; } //!Conversion to boolean. //!Does not throw operator unspecified_bool_type () const BOOST_NOEXCEPT { return m_ptr == 0? 0: &this_type::m_ptr; } //!Not operator. //!Does not throw bool operator! () const BOOST_NOEXCEPT { return m_ptr == 0; } //!Exchanges the contents of the two smart pointers. //!Does not throw void swap(intrusive_ptr & rhs) BOOST_NOEXCEPT { ::boost::adl_move_swap(m_ptr, rhs.m_ptr); } #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED) private: pointer m_ptr; #endif //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED }; //!Returns a.get() == b.get(). //!Does not throw template<class T, class U, class VP> inline bool operator==(intrusive_ptr<T, VP> const & a, intrusive_ptr<U, VP> const & b) BOOST_NOEXCEPT { return a.get() == b.get(); } //!Returns a.get() != b.get(). //!Does not throw template<class T, class U, class VP> inline bool operator!=(intrusive_ptr<T, VP> const & a, intrusive_ptr<U, VP> const & b) BOOST_NOEXCEPT { return a.get() != b.get(); } //!Returns a.get() == b. //!Does not throw template<class T, class VP> inline bool operator==(intrusive_ptr<T, VP> const & a, const typename intrusive_ptr<T, VP>::pointer &b) BOOST_NOEXCEPT { return a.get() == b; } //!Returns a.get() != b. //!Does not throw template<class T, class VP> inline bool operator!=(intrusive_ptr<T, VP> const & a, const typename intrusive_ptr<T, VP>::pointer &b) BOOST_NOEXCEPT { return a.get() != b; } //!Returns a == b.get(). //!Does not throw template<class T, class VP> inline bool operator==(const typename intrusive_ptr<T, VP>::pointer &a, intrusive_ptr<T, VP> const & b) BOOST_NOEXCEPT { return a == b.get(); } //!Returns a != b.get(). //!Does not throw template<class T, class VP> inline bool operator!=(const typename intrusive_ptr<T, VP>::pointer &a, intrusive_ptr<T, VP> const & b) BOOST_NOEXCEPT { return a != b.get(); } //!Returns a.get() < b.get(). //!Does not throw template<class T, class VP> inline bool operator<(intrusive_ptr<T, VP> const & a, intrusive_ptr<T, VP> const & b) BOOST_NOEXCEPT { return std::less<typename intrusive_ptr<T, VP>::pointer>() (a.get(), b.get()); } //!Exchanges the contents of the two intrusive_ptrs. //!Does not throw template<class T, class VP> inline void swap(intrusive_ptr<T, VP> & lhs, intrusive_ptr<T, VP> & rhs) BOOST_NOEXCEPT { lhs.swap(rhs); } // operator<< template<class E, class T, class Y, class VP> inline std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, intrusive_ptr<Y, VP> const & p) BOOST_NOEXCEPT { os << p.get(); return os; } //!Returns p.get(). //!Does not throw template<class T, class VP> inline typename boost::interprocess::intrusive_ptr<T, VP>::pointer to_raw_pointer(intrusive_ptr<T, VP> p) BOOST_NOEXCEPT { return p.get(); } /*Emulates static cast operator. Does not throw*/ /* template<class T, class U, class VP> inline boost::interprocess::intrusive_ptr<T, VP> static_pointer_cast (boost::interprocess::intrusive_ptr<U, VP> const & p) BOOST_NOEXCEPT { return do_static_cast<U>(p.get()); } */ /*Emulates const cast operator. Does not throw*/ /* template<class T, class U, class VP> inline boost::interprocess::intrusive_ptr<T, VP> const_pointer_cast (boost::interprocess::intrusive_ptr<U, VP> const & p) BOOST_NOEXCEPT { return do_const_cast<U>(p.get()); } */ /*Emulates dynamic cast operator. Does not throw*/ /* template<class T, class U, class VP> inline boost::interprocess::intrusive_ptr<T, VP> dynamic_pointer_cast (boost::interprocess::intrusive_ptr<U, VP> const & p) BOOST_NOEXCEPT { return do_dynamic_cast<U>(p.get()); } */ /*Emulates reinterpret cast operator. Does not throw*/ /* template<class T, class U, class VP> inline boost::interprocess::intrusive_ptr<T, VP>reinterpret_pointer_cast (boost::interprocess::intrusive_ptr<U, VP> const & p) BOOST_NOEXCEPT { return do_reinterpret_cast<U>(p.get()); } */ } // namespace interprocess #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED) #if defined(_MSC_VER) && (_MSC_VER < 1400) //!Returns p.get(). //!Does not throw template<class T, class VP> inline T *to_raw_pointer(boost::interprocess::intrusive_ptr<T, VP> p) BOOST_NOEXCEPT { return p.get(); } #endif #endif //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED } // namespace boost #include <boost/interprocess/detail/config_end.hpp> #endif // #ifndef BOOST_INTERPROCESS_INTRUSIVE_PTR_HPP_INCLUDED