| ////////////////////////////////////////////////////////////////////////////// |
| // |
| // This file is the adaptation for Interprocess of boost/scoped_ptr.hpp |
| // |
| // (C) Copyright Greg Colvin and Beman Dawes 1998, 1999. |
| // (C) Copyright Peter Dimov 2001, 2002 |
| // (C) Copyright Ion Gaztanaga 2006. 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_SCOPED_PTR_HPP_INCLUDED |
| #define BOOST_INTERPROCESS_SCOPED_PTR_HPP_INCLUDED |
| |
| #include <boost/interprocess/detail/config_begin.hpp> |
| #include <boost/interprocess/detail/workaround.hpp> |
| #include <boost/interprocess/detail/pointer_type.hpp> |
| #include <boost/assert.hpp> |
| #include <boost/pointer_to_other.hpp> |
| |
| //!\file |
| //!Describes the smart pointer scoped_ptr |
| |
| namespace boost { |
| namespace interprocess { |
| |
| //!scoped_ptr stores a pointer to a dynamically allocated object. |
| //!The object pointed to is guaranteed to be deleted, either on destruction |
| //!of the scoped_ptr, or via an explicit reset. The user can avoid this |
| //!deletion using release(). |
| //!scoped_ptr is parameterized on T (the type of the object pointed to) and |
| //!Deleter (the functor to be executed to delete the internal pointer). |
| //!The internal pointer will be of the same pointer type as typename |
| //!Deleter::pointer type (that is, if typename Deleter::pointer is |
| //!offset_ptr<void>, the internal pointer will be offset_ptr<T>). |
| template<class T, class Deleter> |
| class scoped_ptr |
| : private Deleter |
| { |
| /// @cond |
| scoped_ptr(scoped_ptr const &); |
| scoped_ptr & operator=(scoped_ptr const &); |
| |
| typedef scoped_ptr<T, Deleter> this_type; |
| typedef typename detail::add_reference<T>::type reference; |
| /// @endcond |
| |
| public: |
| |
| typedef T element_type; |
| typedef Deleter deleter_type; |
| typedef typename detail::pointer_type<T, Deleter>::type pointer; |
| |
| //!Provides the type of the internal stored pointer |
| // typedef typename boost::pointer_to_other |
| // <typename Deleter::pointer, T>::type pointer; |
| |
| //!Constructs a scoped_ptr, storing a copy of p(which can be 0) and d. |
| //!Does not throw. |
| explicit scoped_ptr(const pointer &p = 0, const Deleter &d = Deleter()) |
| : Deleter(d), m_ptr(p) // throws if pointer/Deleter copy ctor throws |
| {} |
| |
| //!If the stored pointer is not 0, destroys the object pointed to by the stored pointer. |
| //!calling the operator() of the stored deleter. Never throws |
| ~scoped_ptr() |
| { |
| if(m_ptr){ |
| Deleter &del = static_cast<Deleter&>(*this); |
| del(m_ptr); |
| } |
| } |
| |
| //!Deletes the object pointed to by the stored pointer and then |
| //!stores a copy of p. Never throws |
| void reset(const pointer &p = 0) // never throws |
| { BOOST_ASSERT(p == 0 || p != m_ptr); this_type(p).swap(*this); } |
| |
| //!Deletes the object pointed to by the stored pointer and then |
| //!stores a copy of p and a copy of d. |
| void reset(const pointer &p, const Deleter &d) // never throws |
| { BOOST_ASSERT(p == 0 || p != m_ptr); this_type(p).swap(*this); } |
| |
| //!Assigns internal pointer as 0 and returns previous pointer. This will |
| //!avoid deletion on destructor |
| pointer release() |
| { pointer tmp(m_ptr); m_ptr = 0; return tmp; } |
| |
| //!Returns a reference to the object pointed to by the stored pointer. |
| //!Never throws. |
| reference operator*() const |
| { BOOST_ASSERT(m_ptr != 0); return *m_ptr; } |
| |
| //!Returns the internal stored pointer. |
| //!Never throws. |
| pointer &operator->() |
| { BOOST_ASSERT(m_ptr != 0); return m_ptr; } |
| |
| //!Returns the internal stored pointer. |
| //!Never throws. |
| const pointer &operator->() const |
| { BOOST_ASSERT(m_ptr != 0); return m_ptr; } |
| |
| //!Returns the stored pointer. |
| //!Never throws. |
| pointer & get() |
| { return m_ptr; } |
| |
| //!Returns the stored pointer. |
| //!Never throws. |
| const pointer & get() const |
| { return m_ptr; } |
| |
| typedef pointer this_type::*unspecified_bool_type; |
| |
| //!Conversion to bool |
| //!Never throws |
| operator unspecified_bool_type() const |
| { return m_ptr == 0? 0: &this_type::m_ptr; } |
| |
| //!Returns true if the stored pointer is 0. |
| //!Never throws. |
| bool operator! () const // never throws |
| { return m_ptr == 0; } |
| |
| //!Exchanges the internal pointer and deleter with other scoped_ptr |
| //!Never throws. |
| void swap(scoped_ptr & b) // never throws |
| { detail::do_swap<Deleter>(*this, b); detail::do_swap(m_ptr, b.m_ptr); } |
| |
| /// @cond |
| private: |
| pointer m_ptr; |
| /// @endcond |
| }; |
| |
| //!Exchanges the internal pointer and deleter with other scoped_ptr |
| //!Never throws. |
| template<class T, class D> inline |
| void swap(scoped_ptr<T, D> & a, scoped_ptr<T, D> & b) |
| { a.swap(b); } |
| |
| //!Returns a copy of the stored pointer |
| //!Never throws |
| template<class T, class D> inline |
| typename scoped_ptr<T, D>::pointer get_pointer(scoped_ptr<T, D> const & p) |
| { return p.get(); } |
| |
| } // namespace interprocess |
| |
| /// @cond |
| |
| #if defined(_MSC_VER) && (_MSC_VER < 1400) |
| template<class T, class D> inline |
| T *get_pointer(boost::interprocess::scoped_ptr<T, D> const & p) |
| { return p.get(); } |
| #endif |
| |
| /// @endcond |
| |
| } // namespace boost |
| |
| #include <boost/interprocess/detail/config_end.hpp> |
| |
| #endif // #ifndef BOOST_INTERPROCESS_SCOPED_PTR_HPP_INCLUDED |