boost/interprocess/smart_ptr/weak_ptr.hpp

   1 //////////////////////////////////////////////////////////////////////////////
   2 //
   3 // This file is the adaptation for Interprocess of boost/weak_ptr.hpp
   4 //
   5 // (C) Copyright Peter Dimov 2001, 2002, 2003
   6 // (C) Copyright Ion Gaztanaga 2006-2008.
   7 // Distributed under the Boost Software License, Version 1.0.
   8 // (See accompanying file LICENSE_1_0.txt or copy at
   9 // http://www.boost.org/LICENSE_1_0.txt)
  10 //
  11 // See http://www.boost.org/libs/interprocess for documentation.
  12 //
  13 //////////////////////////////////////////////////////////////////////////////
  14
  15 #ifndef BOOST_INTERPROCESS_WEAK_PTR_HPP_INCLUDED
  16 #define BOOST_INTERPROCESS_WEAK_PTR_HPP_INCLUDED
  17
  18 #include <boost/interprocess/detail/config_begin.hpp>
  19 #include <boost/interprocess/detail/workaround.hpp>
  20
  21 #include <boost/interprocess/smart_ptr/shared_ptr.hpp>
  22 #include <boost/detail/no_exceptions_support.hpp>
  23 #include <boost/interprocess/allocators/allocator.hpp>
  24 #include <boost/interprocess/smart_ptr/deleter.hpp>
  25 #include <boost/pointer_to_other.hpp>
  26
  27 //!\file
  28 //!Describes the smart pointer weak_ptr.
  29
  30 namespace boost{
  31 namespace interprocess{
  32
  33 //!The weak_ptr class template stores a "weak reference" to an object
  34 //!that's already managed by a shared_ptr. To access the object, a weak_ptr
  35 //!can be converted to a shared_ptr using  the shared_ptr constructor or the
  36 //!member function  lock. When the last shared_ptr to the object goes away
  37 //!and the object is deleted, the attempt to obtain a shared_ptr from the
  38 //!weak_ptr instances that refer to the deleted object will fail: the constructor
  39 //!will throw an exception of type bad_weak_ptr, and weak_ptr::lock will
  40 //!return an empty shared_ptr.
  41 //!
  42 //!Every weak_ptr meets the CopyConstructible and Assignable requirements
  43 //!of the C++ Standard Library, and so can be used in standard library containers.
  44 //!Comparison operators are supplied so that weak_ptr works with the standard
  45 //!library's associative containers.
  46 //!
  47 //!weak_ptr operations never throw exceptions.
  48 //!
  49 //!The class template is parameterized on T, the type of the object pointed to.
  50 template<class T, class A, class D>
  51 class weak_ptr
  52 {
  53    /// @cond
  54    private:
  55    // Borland 5.5.1 specific workarounds
  56    typedef weak_ptr<T, A, D> this_type;
  57    typedef typename boost::pointer_to_other
  58       <typename A::pointer, T>::type      pointer;
  59    typedef typename detail::add_reference
  60                      <T>::type            reference;
  61    typedef typename detail::add_reference
  62                      <T>::type            const_reference;
  63    /// @endcond
  64
  65    public:
  66    typedef T element_type;
  67    typedef T value_type;
  68
  69    //!Effects: Constructs an empty weak_ptr.
  70    //!Postconditions: use_count() == 0.
  71    weak_ptr()
  72    : m_pn() // never throws
  73    {}
  74    //  generated copy constructor, assignment, destructor are fine
  75    //
  76    //  The "obvious" converting constructor implementation:
  77    //
  78    //  template<class Y>
  79    //  weak_ptr(weak_ptr<Y> const & r): m_px(r.m_px), m_pn(r.m_pn) // never throws
  80    //  {
  81    //  }
  82    //
  83    //  has a serious problem.
  84    //
  85    //  r.m_px may already have been invalidated. The m_px(r.m_px)
  86    //  conversion may require access to *r.m_px (virtual inheritance).
  87    //
  88    //  It is not possible to avoid spurious access violations since
  89    //  in multithreaded programs r.m_px may be invalidated at any point.
  90
  91    //!Effects: If r is empty, constructs an empty weak_ptr; otherwise,
  92    //!constructs a weak_ptr that shares ownership with r as if by storing a
  93    //!copy of the pointer stored in r.
  94    //!
  95    //!Postconditions: use_count() == r.use_count().
  96    //!
  97    //!Throws: nothing.
  98    template<class Y>
  99    weak_ptr(weak_ptr<Y, A, D> const & r)
 100       : m_pn(r.m_pn) // never throws
 101    {
 102       //Construct a temporary shared_ptr so that nobody
 103       //can destroy the value while constructing this
 104       const shared_ptr<T, A, D> &ref = r.lock();
 105       m_pn.set_pointer(ref.get());
 106    }
 107
 108    //!Effects: If r is empty, constructs an empty weak_ptr; otherwise,
 109    //!constructs a weak_ptr that shares ownership with r as if by storing a
 110    //!copy of the pointer stored in r.
 111    //!
 112    //!Postconditions: use_count() == r.use_count().
 113    //!
 114    //!Throws: nothing.
 115    template<class Y>
 116    weak_ptr(shared_ptr<Y, A, D> const & r)
 117       : m_pn(r.m_pn) // never throws
 118    {}
 119
 120    //!Effects: Equivalent to weak_ptr(r).swap(*this).
 121    //!
 122    //!Throws: nothing.
 123    //!
 124    //!Notes: The implementation is free to meet the effects (and the
 125    //!implied guarantees) via different means, without creating a temporary.
 126    template<class Y>
 127    weak_ptr & operator=(weak_ptr<Y, A, D> const & r) // never throws
 128    {
 129       //Construct a temporary shared_ptr so that nobody
 130       //can destroy the value while constructing this
 131       const shared_ptr<T, A, D> &ref = r.lock();
 132       m_pn = r.m_pn;
 133       m_pn.set_pointer(ref.get());
 134       return *this;
 135    }
 136
 137    //!Effects: Equivalent to weak_ptr(r).swap(*this).
 138    //!
 139    //!Throws: nothing.
 140    //!
 141    //!Notes: The implementation is free to meet the effects (and the
 142    //!implied guarantees) via different means, without creating a temporary.
 143    template<class Y>
 144    weak_ptr & operator=(shared_ptr<Y, A, D> const & r) // never throws
 145    {  m_pn = r.m_pn;  return *this;  }
 146
 147    //!Returns: expired()? shared_ptr<T>(): shared_ptr<T>(*this).
 148    //!
 149    //!Throws: nothing.
 150    shared_ptr<T, A, D> lock() const // never throws
 151    {
 152       // optimization: avoid throw overhead
 153       if(expired()){
 154          return shared_ptr<element_type, A, D>();
 155       }
 156       BOOST_TRY{
 157          return shared_ptr<element_type, A, D>(*this);
 158       }
 159       BOOST_CATCH(bad_weak_ptr const &){
 160          // Q: how can we get here?
 161          // A: another thread may have invalidated r after the use_count test above.
 162          return shared_ptr<element_type, A, D>();
 163       }
 164       BOOST_CATCH_END
 165    }
 166
 167    //!Returns: 0 if *this is empty; otherwise, the number of shared_ptr objects
 168    //!that share ownership with *this.
 169    //!
 170    //!Throws: nothing.
 171    //!
 172    //!Notes: use_count() is not necessarily efficient. Use only for debugging and
 173    //!testing purposes, not for production code.
 174    long use_count() const // never throws
 175    {  return m_pn.use_count();  }
 176
 177    //!Returns: Returns: use_count() == 0.
 178    //!
 179    //!Throws: nothing.
 180    //!
 181    //!Notes: expired() may be faster than use_count().
 182    bool expired() const // never throws
 183    {  return m_pn.use_count() == 0;   }
 184
 185    //!Effects: Equivalent to:
 186    //!weak_ptr().swap(*this).
 187    void reset() // never throws in 1.30+
 188    {  this_type().swap(*this);   }
 189
 190    //!Effects: Exchanges the contents of the two
 191    //!smart pointers.
 192    //!
 193    //!Throws: nothing.
 194    void swap(this_type & other) // never throws
 195    {  detail::do_swap(m_pn, other.m_pn);   }
 196
 197    /// @cond
 198    template<class T2, class A2, class D2>
 199    bool _internal_less(weak_ptr<T2, A2, D2> const & rhs) const
 200    {  return m_pn < rhs.m_pn;  }
 201
 202    template<class Y>
 203    void _internal_assign(const detail::shared_count<Y, A, D> & pn2)
 204    {
 205
 206       m_pn = pn2;
 207    }
 208
 209    private:
 210
 211    template<class T2, class A2, class D2> friend class shared_ptr;
 212    template<class T2, class A2, class D2> friend class weak_ptr;
 213
 214    detail::weak_count<T, A, D> m_pn;      // reference counter
 215    /// @endcond
 216 };  // weak_ptr
 217
 218 template<class T, class A, class D, class U, class A2, class D2> inline
 219 bool operator<(weak_ptr<T, A, D> const & a, weak_ptr<U, A2, D2> const & b)
 220 {  return a._internal_less(b);   }
 221
 222 template<class T, class A, class D> inline
 223 void swap(weak_ptr<T, A, D> & a, weak_ptr<T, A, D> & b)
 224 {  a.swap(b);  }
 225
 226 //!Returns the type of a weak pointer
 227 //!of type T with the allocator boost::interprocess::allocator allocator
 228 //!and boost::interprocess::deleter deleter
 229 //!that can be constructed in the given managed segment type.
 230 template<class T, class ManagedMemory>
 231 struct managed_weak_ptr
 232 {
 233    typedef weak_ptr
 234    < T
 235    , typename ManagedMemory::template allocator<void>::type
 236    , typename ManagedMemory::template deleter<T>::type
 237    > type;
 238 };
 239
 240 //!Returns an instance of a weak pointer constructed
 241 //!with the default allocator and deleter from a pointer
 242 //!of type T that has been allocated in the passed managed segment
 243 template<class T, class ManagedMemory>
 244 inline typename managed_weak_ptr<T, ManagedMemory>::type
 245    make_managed_weak_ptr(T *constructed_object, ManagedMemory &managed_memory)
 246 {
 247    return typename managed_weak_ptr<T, ManagedMemory>::type
 248    ( constructed_object
 249    , managed_memory.template get_allocator<void>()
 250    , managed_memory.template get_deleter<T>()
 251    );
 252 }
 253
 254 } // namespace interprocess
 255 } // namespace boost
 256
 257 #include <boost/interprocess/detail/config_end.hpp>
 258
 259 #endif  // #ifndef BOOST_INTERPROCESS_WEAK_PTR_HPP_INCLUDED