Rietveld Code Review Tool
Help | Bug tracker | Discussion group | Source code

Side by Side Diff: compiled/intrusive_ptr.h

Issue 29333474: Issue 4125 - [emscripten] Convert filter classes to C++ (Closed)
Patch Set: Replaced old filter classes unit tests completely Created Feb. 18, 2016, 4:40 p.m.
Left:
Right:
Use n/p to move between diff chunks; N/P to move between comments.
Jump to:
View unified diff | Download patch
« no previous file with comments | « compiled/debug.h ('k') | compiled/shell.js » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Parts of this code have been copied from boost/smart_ptr/intrusive_ptr.hpp.
2 //
3 // Copyright (c) 2001, 2002 Peter Dimov
4 //
5 // Distributed under the Boost Software License, Version 1.0. (See
6 // accompanying file LICENSE_1_0.txt or copy at
7 // http://www.boost.org/LICENSE_1_0.txt)
8
9 #pragma once
10
11 #include <algorithm>
12 #include <type_traits>
13
14 class ref_counted
15 {
16 public:
17 void AddRef()
18 {
19 mRefCount++;
20 }
21
22 void ReleaseRef()
23 {
24 if (--mRefCount == 0)
25 delete this;
26 }
27
28 protected:
29 ref_counted()
30 : mRefCount(0)
31 {
32 }
33
34 // We need this virtual destructor, otherwise pointers to ref_counted and
35 // pointers to derived classes won't have the same value (e.g. converting from
36 // Filter* to ref_counted* decreases pointer value by 4).
37 virtual ~ref_counted()
38 {
39 }
40
41 private:
42 int mRefCount;
43 };
44
45 template<typename T,
46 class = typename std::enable_if<std::is_base_of<ref_counted,T>::value>::type >
47 class intrusive_ptr
48 {
49 public:
50 intrusive_ptr()
51 : mPointer(nullptr)
52 {
53 }
54
55 intrusive_ptr(T* pointer)
56 : mPointer(pointer)
57 {
58 if (mPointer)
59 mPointer->AddRef();
60 }
61
62 intrusive_ptr(const intrusive_ptr& other)
63 : mPointer(other.mPointer)
64 {
65 if (mPointer)
66 mPointer->AddRef();
67 }
68
69 intrusive_ptr(intrusive_ptr&& other)
70 : mPointer(other.mPointer)
71 {
72 other.mPointer = nullptr;
73 }
74
75 ~intrusive_ptr()
76 {
77 if (mPointer)
78 mPointer->ReleaseRef();
79 }
80
81 intrusive_ptr& operator=(intrusive_ptr& other)
82 {
83 intrusive_ptr(other).swap(*this);
84 return *this;
85 }
86
87 intrusive_ptr& operator=(intrusive_ptr&& other)
88 {
89 intrusive_ptr(std::move(other)).swap(*this);
90 return *this;
91 }
92
93 intrusive_ptr& operator=(T* other)
94 {
95 intrusive_ptr(other).swap(*this);
96 return *this;
97 }
98
99 void reset()
100 {
101 intrusive_ptr().swap(*this);
102 }
103
104 void reset(T* other)
105 {
106 intrusive_ptr(other).swap(*this);
107 }
108
109 const T* get() const
110 {
111 return mPointer;
112 }
113
114 T* get()
115 {
116 return mPointer;
117 }
118
119 const T& operator*() const
120 {
121 return *mPointer;
122 }
123
124 T& operator*()
125 {
126 return *mPointer;
127 }
128
129 const T* operator->() const
130 {
131 return mPointer;
132 }
133
134 T* operator->()
135 {
136 return mPointer;
137 }
138
139 operator bool() const
140 {
141 return mPointer != nullptr;
142 }
143
144 operator T*() const
145 {
146 return mPointer;
147 }
148
149 bool operator!() const
150 {
151 return mPointer == nullptr;
152 }
153
154 void swap(intrusive_ptr& other)
155 {
156 std::swap(mPointer, other.mPointer);
157 }
158
159 private:
160 T* mPointer;
161 };
162
163 template<typename T, typename U>
164 inline bool operator==(const intrusive_ptr<T>& a, const intrusive_ptr<U>& b)
165 {
166 return a.get() == b.get();
167 }
168
169 template<typename T, typename U>
170 inline bool operator!=(const intrusive_ptr<T>& a, const intrusive_ptr<U>& b)
171 {
172 return a.get() != b.get();
173 }
174
175 template<typename T, typename U>
176 inline bool operator==(const intrusive_ptr<T>& a, const U* b)
177 {
178 return a.get() == b;
179 }
180
181 template<typename T, typename U>
182 inline bool operator!=(const intrusive_ptr<T>& a, const U* b)
183 {
184 return a.get() != b;
185 }
186
187 template<typename T, typename U>
188 inline bool operator==(const T* a, const intrusive_ptr<U>& b)
189 {
190 return a == b.get();
191 }
192
193 template<typename T, typename U>
194 inline bool operator!=(const T* a, intrusive_ptr<U> const& b)
195 {
196 return a != b.get();
197 }
OLDNEW
« no previous file with comments | « compiled/debug.h ('k') | compiled/shell.js » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld