Index: compiled/intrusive_ptr.h |
=================================================================== |
new file mode 100644 |
--- /dev/null |
+++ b/compiled/intrusive_ptr.h |
@@ -0,0 +1,197 @@ |
+// Parts of this code have been copied from boost/smart_ptr/intrusive_ptr.hpp. |
+// |
+// Copyright (c) 2001, 2002 Peter Dimov |
+// |
+// 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) |
+ |
+#pragma once |
+ |
+#include <algorithm> |
+#include <type_traits> |
+ |
+class ref_counted |
+{ |
+public: |
+ void AddRef() |
+ { |
+ mRefCount++; |
+ } |
+ |
+ void ReleaseRef() |
+ { |
+ if (--mRefCount == 0) |
+ delete this; |
+ } |
+ |
+protected: |
+ ref_counted() |
+ : mRefCount(0) |
+ { |
+ } |
+ |
+ // We need this virtual destructor, otherwise pointers to ref_counted and |
+ // pointers to derived classes won't have the same value (e.g. converting from |
+ // Filter* to ref_counted* decreases pointer value by 4). |
+ virtual ~ref_counted() |
+ { |
+ } |
+ |
+private: |
+ int mRefCount; |
+}; |
+ |
+template<typename T, |
+ class = typename std::enable_if<std::is_base_of<ref_counted,T>::value>::type> |
+class intrusive_ptr |
+{ |
+public: |
+ intrusive_ptr() |
+ : mPointer(nullptr) |
+ { |
+ } |
+ |
+ intrusive_ptr(T* pointer) |
+ : mPointer(pointer) |
+ { |
+ if (mPointer) |
+ mPointer->AddRef(); |
+ } |
+ |
+ intrusive_ptr(const intrusive_ptr& other) |
+ : mPointer(other.mPointer) |
+ { |
+ if (mPointer) |
+ mPointer->AddRef(); |
+ } |
+ |
+ intrusive_ptr(intrusive_ptr&& other) |
+ : mPointer(other.mPointer) |
+ { |
+ other.mPointer = nullptr; |
+ } |
+ |
+ ~intrusive_ptr() |
+ { |
+ if (mPointer) |
+ mPointer->ReleaseRef(); |
+ } |
+ |
+ intrusive_ptr& operator=(intrusive_ptr& other) |
+ { |
+ intrusive_ptr(other).swap(*this); |
+ return *this; |
+ } |
+ |
+ intrusive_ptr& operator=(intrusive_ptr&& other) |
+ { |
+ intrusive_ptr(std::move(other)).swap(*this); |
+ return *this; |
+ } |
+ |
+ intrusive_ptr& operator=(T* other) |
+ { |
+ intrusive_ptr(other).swap(*this); |
+ return *this; |
+ } |
+ |
+ void reset() |
+ { |
+ intrusive_ptr().swap(*this); |
+ } |
+ |
+ void reset(T* other) |
+ { |
+ intrusive_ptr(other).swap(*this); |
+ } |
+ |
+ const T* get() const |
+ { |
+ return mPointer; |
+ } |
+ |
+ T* get() |
+ { |
+ return mPointer; |
+ } |
+ |
+ const T& operator*() const |
+ { |
+ return *mPointer; |
+ } |
+ |
+ T& operator*() |
+ { |
+ return *mPointer; |
+ } |
+ |
+ const T* operator->() const |
+ { |
+ return mPointer; |
+ } |
+ |
+ T* operator->() |
+ { |
+ return mPointer; |
+ } |
+ |
+ operator bool() const |
+ { |
+ return mPointer != nullptr; |
+ } |
+ |
+ operator T*() const |
+ { |
+ return mPointer; |
+ } |
+ |
+ bool operator!() const |
+ { |
+ return mPointer == nullptr; |
+ } |
+ |
+ void swap(intrusive_ptr& other) |
+ { |
+ std::swap(mPointer, other.mPointer); |
+ } |
+ |
+private: |
+ T* mPointer; |
+}; |
+ |
+template<typename T, typename U> |
+inline bool operator==(const intrusive_ptr<T>& a, const intrusive_ptr<U>& b) |
+{ |
+ return a.get() == b.get(); |
+} |
+ |
+template<typename T, typename U> |
+inline bool operator!=(const intrusive_ptr<T>& a, const intrusive_ptr<U>& b) |
+{ |
+ return a.get() != b.get(); |
+} |
+ |
+template<typename T, typename U> |
+inline bool operator==(const intrusive_ptr<T>& a, const U* b) |
+{ |
+ return a.get() == b; |
+} |
+ |
+template<typename T, typename U> |
+inline bool operator!=(const intrusive_ptr<T>& a, const U* b) |
+{ |
+ return a.get() != b; |
+} |
+ |
+template<typename T, typename U> |
+inline bool operator==(const T* a, const intrusive_ptr<U>& b) |
+{ |
+ return a == b.get(); |
+} |
+ |
+template<typename T, typename U> |
+inline bool operator!=(const T* a, intrusive_ptr<U> const& b) |
+{ |
+ return a != b.get(); |
+} |