GEEKING

Base/include/rbx/intrusive_weak_ptr.h

@@ -0,0 +1,131 @@
+#pragma once
+
+#include "boost/intrusive_ptr.hpp"
+
+namespace rbx
+{
+	/*
+		An extension to boost::intrusive_ptr.
+		To use this class, the target class needs to implement
+		some functions in addition to those required by boost::instrusive_ptr:
+
+			bool intrusive_ptr_expired(const T* p);
+			bool intrusive_ptr_try_lock(const T* p);
+			void intrusive_ptr_add_weak_ref(const T* p);
+			void intrusive_ptr_weak_release(const T* p);
+
+		Note: rbx::intrusive_ptr_target is a nice wrapper class that implements
+		      all required functions
+
+	*/
+	template<class T> 
+	class intrusive_weak_ptr
+	{
+		T* p_;
+
+	public:
+		inline intrusive_weak_ptr(): p_(0)
+		{
+		}
+
+		inline intrusive_weak_ptr(T * p): p_(p)
+		{
+			if(p_ != 0) boost::intrusive_ptr_add_weak_ref(p_);
+		}
+
+	    template<class U>
+		inline intrusive_weak_ptr( const intrusive_weak_ptr<U>& rhs)
+		: p_( 0 )
+		{
+			if (!rhs.expired()) 
+			{	
+				p_ = rhs.raw();			
+				boost::intrusive_ptr_add_weak_ref(p_);
+			}
+		}
+
+		inline intrusive_weak_ptr( const intrusive_weak_ptr& rhs)
+		: p_( 0 )
+		{
+			if (!rhs.expired()) 
+			{	
+				p_ = rhs.raw();			
+				boost::intrusive_ptr_add_weak_ref(p_);
+			}
+		}
+
+	    template<class U>
+		inline intrusive_weak_ptr( const boost::intrusive_ptr<U>& rhs)
+		: p_( rhs.get() )
+		{
+			if( p_ != 0 ) boost::intrusive_ptr_add_weak_ref(p_);
+		}
+
+	    template<class U>
+		inline intrusive_weak_ptr& operator=(T * p)
+		{
+			reset(p);
+			return *this;
+		}
+
+	    template<class U>
+		inline intrusive_weak_ptr& operator=(const boost::intrusive_ptr<U> & rhs)
+		{
+			reset(rhs.get());
+			return *this;
+		}
+
+		inline intrusive_weak_ptr& operator=(const rbx::intrusive_weak_ptr<T>& rhs)
+		{
+			reset(rhs.raw());
+			return *this;
+		}
+
+	    template<class U>
+		inline intrusive_weak_ptr& operator=(const rbx::intrusive_weak_ptr<U>& rhs)
+		{
+			reset(rhs.raw());
+			return *this;
+		}
+
+		inline ~intrusive_weak_ptr()
+		{
+			if( p_ != 0 ) boost::intrusive_ptr_weak_release(p_);
+		}
+
+		inline void reset()
+		{
+			if( p_ != 0 ) 
+			{
+				boost::intrusive_ptr_weak_release(p_);
+				p_ = 0;
+			}
+		}
+
+		inline void reset(T* p)
+		{
+			if( p_ != 0 ) boost::intrusive_ptr_weak_release(p_);
+			p_ = p;
+			if( p_ != 0 ) boost::intrusive_ptr_add_weak_ref(p_);
+		}
+
+		inline boost::intrusive_ptr<T> lock() const
+		{
+			if (p_ && boost::intrusive_ptr_try_lock(p_))
+				return boost::intrusive_ptr<T>(p_, false);
+			else
+				return boost::intrusive_ptr<T>();
+		}
+
+		inline bool expired() const
+		{
+			return (!p_ || boost::intrusive_ptr_expired(p_));
+		}
+
+		// TODO: Can we hide this?
+		inline T* raw() const
+		{
+			return p_;
+		}
+	};	
+}