CppCMS

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

weak_ptr.h
1 #ifndef BOOSTER_SMART_PTR_WEAK_PTR_HPP_INCLUDED
2 #define BOOSTER_SMART_PTR_WEAK_PTR_HPP_INCLUDED
3
4 //
5 // weak_ptr.hpp
6 //
7 // Copyright (c) 2001, 2002, 2003 Peter Dimov
8 //
9 // Distributed under the Boost Software License, Version 1.0. (See
10 // accompanying file LICENSE_1_0.txt or copy at
11 // http://www.boost.org/LICENSE_1_0.txt)
12 //
13 // See http://www.boost.org/libs/smart_ptr/weak_ptr.htm for documentation.
14 //
15
16 #include <booster/auto_ptr_inc.h> // boost.TR1 include order fix
17 #include <booster/smart_ptr/shared_count.h>
18 #include <booster/shared_ptr.h>
19
20 #ifdef BOOSTER_MSVC // moved here to work around VC++ compiler crash
21 # pragma warning(push)
22 # pragma warning(disable:4284) // odd return type for operator->
23 #endif
24
25 namespace booster
26 {
27
28 template<class T> class weak_ptr
29 {
30 private:
31
32 // Borland 5.5.1 specific workarounds
33 typedef weak_ptr<T> this_type;
34
35 public:
36
37 typedef T element_type;
38
39 weak_ptr(): px(0), pn() // never throws in 1.30+
40 {
41 }
42
43 // generated copy constructor, assignment, destructor are fine
44
45
46 //
47 // The "obvious" converting constructor implementation:
48 //
49 // template<class Y>
50 // weak_ptr(weak_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
51 // {
52 // }
53 //
54 // has a serious problem.
55 //
56 // r.px may already have been invalidated. The px(r.px)
57 // conversion may require access to *r.px (virtual inheritance).
58 //
59 // It is not possible to avoid spurious access violations since
60 // in multithreaded programs r.px may be invalidated at any point.
61 //
62
63 template<class Y>
64 weak_ptr( weak_ptr<Y> const & r, typename detail::sp_enable_if_convertible<Y,T>::type = detail::sp_empty() )
65 : px(r.lock().get()), pn(r.pn) // never throws
66 {
67 }
68
69
70 template<class Y>
71 weak_ptr( shared_ptr<Y> const & r, typename detail::sp_enable_if_convertible<Y,T>::type = detail::sp_empty() )
72 : px( r.px ), pn( r.pn ) // never throws
73 {
74 }
75
76 template<class Y>
77 weak_ptr & operator=(weak_ptr<Y> const & r) // never throws
78 {
79 px = r.lock().get();
80 pn = r.pn;
81 return *this;
82 }
83
84 template<class Y>
85 weak_ptr & operator=(shared_ptr<Y> const & r) // never throws
86 {
87 px = r.px;
88 pn = r.pn;
89 return *this;
90 }
91
92 shared_ptr<T> lock() const // never throws
93 {
94 return shared_ptr<element_type>( *this, booster::detail::sp_nothrow_tag() );
95 }
96
97 long use_count() const // never throws
98 {
99 return pn.use_count();
100 }
101
102 bool expired() const // never throws
103 {
104 return pn.use_count() == 0;
105 }
106
107 bool _empty() const // extension, not in std::weak_ptr
108 {
109 return pn.empty();
110 }
111
112 void reset() // never throws in 1.30+
113 {
114 this_type().swap(*this);
115 }
116
117 void swap(this_type & other) // never throws
118 {
119 std::swap(px, other.px);
120 pn.swap(other.pn);
121 }
122
123 void _internal_assign(T * px2, booster::detail::shared_count const & pn2)
124 {
125 px = px2;
126 pn = pn2;
127 }
128
129 template<class Y> bool _internal_less(weak_ptr<Y> const & rhs) const
130 {
131 return pn < rhs.pn;
132 }
133
134 // Tasteless as this may seem, making all members public allows member templates
135 // to work in the absence of member template friends. (Matthew Langston)
136
137 private:
138
139 template<class Y> friend class weak_ptr;
140 template<class Y> friend class shared_ptr;
141
142 T * px; // contained pointer
143 booster::detail::weak_count pn; // reference counter
144
145 }; // weak_ptr
146
147 template<class T, class U> inline bool operator<(weak_ptr<T> const & a, weak_ptr<U> const & b)
148 {
149 return a._internal_less(b);
150 }
151
152 template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b)
153 {
154 a.swap(b);
155 }
156
157 } // namespace boost
158
159 #ifdef BOOSTER_MSVC
160 # pragma warning(pop)
161 #endif
162
163 #endif // #ifndef BOOST_SMART_PTR_WEAK_PTR_HPP_INCLUDED
booster::detail::shared_count
Definition: shared_count.h:37
booster::detail::weak_count
Definition: shared_count.h:179
booster::detail::sp_nothrow_tag
Definition: shared_count.h:33
booster
Booster library namespace. The library that implements Boost Like API in ABI backward compatible way...
Definition: application.h:23