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

Delta Between Two Patch Sets: compiled/intrusive_ptr.h

Issue 29333474: Issue 4125 - [emscripten] Convert filter classes to C++ (Closed)
Left Patch Set: Replaced old filter classes unit tests completely Created Feb. 18, 2016, 4:40 p.m.
Right Patch Set: Addressed comments from Patch Set 28 Created March 21, 2017, 10:04 a.m.
Left:
Right:
Use n/p to move between diff chunks; N/P to move between comments.
Jump to:
Left: Side by side diff | Download
Right: Side by side diff | Download
« no previous file with change/comment | « compiled/debug.h ('k') | compiled/shell.js » ('j') | no next file with change/comment »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
LEFTRIGHT
1 // Parts of this code have been copied from boost/smart_ptr/intrusive_ptr.hpp. 1 // Parts of this code have been copied from boost/smart_ptr/intrusive_ptr.hpp.
2 // 2 //
3 // Copyright (c) 2001, 2002 Peter Dimov 3 // Copyright (c) 2001, 2002 Peter Dimov
4 // 4 //
5 // Distributed under the Boost Software License, Version 1.0. (See 5 // Distributed under the Boost Software License, Version 1.0. (See
6 // accompanying file LICENSE_1_0.txt or copy at 6 // accompanying file LICENSE_1_0.txt or copy at
7 // http://www.boost.org/LICENSE_1_0.txt) 7 // http://www.boost.org/LICENSE_1_0.txt)
8 8
9 #pragma once 9 #pragma once
10 10
11 #include <algorithm> 11 #include <algorithm>
12 #include <type_traits> 12 #include <type_traits>
13 13
14 #include "debug.h"
15
14 class ref_counted 16 class ref_counted
15 { 17 {
16 public: 18 public:
17 void AddRef() 19 void AddRef()
18 { 20 {
19 mRefCount++; 21 mRefCount++;
20 } 22 }
21 23
22 void ReleaseRef() 24 void ReleaseRef()
23 { 25 {
26 assert(mRefCount > 0, u"Unexpected zero or negative reference count"_str);
24 if (--mRefCount == 0) 27 if (--mRefCount == 0)
25 delete this; 28 delete this;
26 } 29 }
27 30
28 protected: 31 protected:
29 ref_counted() 32 ref_counted()
30 : mRefCount(0) 33 : mRefCount(1)
31 { 34 {
32 } 35 }
33 36
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() 37 virtual ~ref_counted()
38 { 38 {
39 assert(mRefCount == 0, u"Destroying a ref-counted object with a non-zero ref erence count"_str);
39 } 40 }
40 41
41 private: 42 private:
42 int mRefCount; 43 int mRefCount;
43 }; 44 };
44 45
45 template<typename T, 46 template<typename T,
46 class = typename std::enable_if<std::is_base_of<ref_counted,T>::value>::type > 47 class = typename std::enable_if<std::is_base_of<ref_counted,T>::value>::type >
47 class intrusive_ptr 48 class intrusive_ptr
48 { 49 {
49 public: 50 public:
50 intrusive_ptr() 51 explicit intrusive_ptr()
51 : mPointer(nullptr) 52 : mPointer(nullptr)
52 { 53 {
53 } 54 }
54 55
55 intrusive_ptr(T* pointer) 56 explicit intrusive_ptr(T* pointer)
56 : mPointer(pointer) 57 : mPointer(pointer)
58 {
59 // Raw pointers always had their reference count increased by whatever gave
60 // us the pointer so we don't need to do it here.
61 }
62
63 intrusive_ptr(const intrusive_ptr& other)
64 : mPointer(other.mPointer)
57 { 65 {
58 if (mPointer) 66 if (mPointer)
59 mPointer->AddRef(); 67 mPointer->AddRef();
60 } 68 }
61 69
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 intrusive_ptr(intrusive_ptr&& other)
70 : mPointer(other.mPointer) 71 : mPointer(other.mPointer)
71 { 72 {
72 other.mPointer = nullptr; 73 other.mPointer = nullptr;
73 } 74 }
74 75
75 ~intrusive_ptr() 76 ~intrusive_ptr()
76 { 77 {
77 if (mPointer) 78 if (mPointer)
78 mPointer->ReleaseRef(); 79 mPointer->ReleaseRef();
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after
129 const T* operator->() const 130 const T* operator->() const
130 { 131 {
131 return mPointer; 132 return mPointer;
132 } 133 }
133 134
134 T* operator->() 135 T* operator->()
135 { 136 {
136 return mPointer; 137 return mPointer;
137 } 138 }
138 139
139 operator bool() const 140 explicit operator bool() const
140 { 141 {
141 return mPointer != nullptr; 142 return mPointer != nullptr;
142 } 143 }
143 144
144 operator T*() const
145 {
146 return mPointer;
147 }
148
149 bool operator!() const 145 bool operator!() const
150 { 146 {
151 return mPointer == nullptr; 147 return mPointer == nullptr;
148 }
149
150 T* release()
151 {
152 T* result = mPointer;
153 mPointer = nullptr;
154 return result;
152 } 155 }
153 156
154 void swap(intrusive_ptr& other) 157 void swap(intrusive_ptr& other)
155 { 158 {
156 std::swap(mPointer, other.mPointer); 159 std::swap(mPointer, other.mPointer);
157 } 160 }
158 161
159 private: 162 private:
160 T* mPointer; 163 T* mPointer;
161 }; 164 };
(...skipping 26 matching lines...) Expand all
188 inline bool operator==(const T* a, const intrusive_ptr<U>& b) 191 inline bool operator==(const T* a, const intrusive_ptr<U>& b)
189 { 192 {
190 return a == b.get(); 193 return a == b.get();
191 } 194 }
192 195
193 template<typename T, typename U> 196 template<typename T, typename U>
194 inline bool operator!=(const T* a, intrusive_ptr<U> const& b) 197 inline bool operator!=(const T* a, intrusive_ptr<U> const& b)
195 { 198 {
196 return a != b.get(); 199 return a != b.get();
197 } 200 }
LEFTRIGHT

Powered by Google App Engine
This is Rietveld