sunshine-external merge WIP

1 files changed, 49 insertions, 132 deletions

diff --git a/indra/llcommon/llpointer.h b/indra/llcommon/llpointer.h
index dd43e3aaa2..c9ebc70d19 100755
--- a/indra/llcommon/llpointer.h
+++ b/indra/llcommon/llpointer.h
@@ -27,6 +27,7 @@
 #define LLPOINTER_H
 
 #include "llerror.h"	// *TODO: consider eliminating this
+#include "llmutex.h"
 
 //----------------------------------------------------------------------------
 // RefCount objects should generally only be accessed by way of LLPointer<>'s
@@ -97,24 +98,13 @@ public:
 
 	LLPointer<Type>& operator =(Type* ptr)                   
 	{ 
-		if( mPointer != ptr )
-		{
-			unref(); 
-			mPointer = ptr; 
-			ref();
-		}
-
+		assign(ptr);
 		return *this; 
 	}
 
 	LLPointer<Type>& operator =(const LLPointer<Type>& ptr)  
 	{ 
-		if( mPointer != ptr.mPointer )
-		{
-			unref(); 
-			mPointer = ptr.mPointer;
-			ref();
-		}
+		assign(ptr);
 		return *this; 
 	}
 
@@ -122,12 +112,7 @@ public:
 	template<typename Subclass>
 	LLPointer<Type>& operator =(const LLPointer<Subclass>& ptr)  
 	{ 
-		if( mPointer != ptr.get() )
-		{
-			unref(); 
-			mPointer = ptr.get();
-			ref();
-		}
+		assign(ptr.get());
 		return *this; 
 	}
 	
@@ -144,6 +129,16 @@ protected:
 	void ref();                             
 	void unref();
 #else
+
+	void assign(const LLPointer<Type>& ptr)
+	{
+		if( mPointer != ptr.mPointer )
+		{
+			unref(); 
+			mPointer = ptr.mPointer;
+			ref();
+		}
+	}
 	void ref()                             
 	{ 
 		if (mPointer)
@@ -156,12 +151,12 @@ protected:
 	{
 		if (mPointer)
 		{
-			Type *tempp = mPointer;
+			Type *temp = mPointer;
 			mPointer = NULL;
-			tempp->unref();
+			temp->unref();
 			if (mPointer != NULL)
 			{
-				llwarns << "Unreference did assignment to non-NULL because of destructor" << llendl;
+				LL_WARNS() << "Unreference did assignment to non-NULL because of destructor" << LL_ENDL;
 				unref();
 			}
 		}
@@ -171,130 +166,52 @@ protected:
 	Type*	mPointer;
 };
 
-template <class Type> class LLConstPointer
+template<typename Type>
+class LLCopyOnWritePointer : public LLPointer<Type>
 {
 public:
-	LLConstPointer() : 
-		mPointer(NULL)
-	{
-	}
-
-	LLConstPointer(const Type* ptr) : 
-		mPointer(ptr)
-	{
-		ref();
-	}
-
-	LLConstPointer(const LLConstPointer<Type>& ptr) : 
-		mPointer(ptr.mPointer)
-	{
-		ref();
-	}
-
-	// support conversion up the type hierarchy.  See Item 45 in Effective C++, 3rd Ed.
-	template<typename Subclass>
-	LLConstPointer(const LLConstPointer<Subclass>& ptr) : 
-		mPointer(ptr.get())
-	{
-		ref();
-	}
-
-	~LLConstPointer()
-	{
-		unref();
-	}
-
-	const Type*	get() const						{ return mPointer; }
-	const Type*	operator->() const				{ return mPointer; }
-	const Type&	operator*() const				{ return *mPointer; }
-
-	operator BOOL()  const						{ return (mPointer != NULL); }
-	operator bool()  const						{ return (mPointer != NULL); }
-	bool operator!() const						{ return (mPointer == NULL); }
-	bool isNull() const							{ return (mPointer == NULL); }
-	bool notNull() const						{ return (mPointer != NULL); }
-
-	operator const Type*()       const			{ return mPointer; }
-	bool operator !=(const Type* ptr) const     { return (mPointer != ptr); 	}
-	bool operator ==(const Type* ptr) const     { return (mPointer == ptr); 	}
-	bool operator ==(const LLConstPointer<Type>& ptr) const           { return (mPointer == ptr.mPointer); 	}
-	bool operator < (const LLConstPointer<Type>& ptr) const           { return (mPointer < ptr.mPointer); 	}
-	bool operator > (const LLConstPointer<Type>& ptr) const           { return (mPointer > ptr.mPointer); 	}
-
-	LLConstPointer<Type>& operator =(const Type* ptr)                   
+	typedef LLCopyOnWritePointer<Type> self_t;
+    typedef LLPointer<Type> pointer_t;
+    
+	LLCopyOnWritePointer() 
+	:	mStayUnique(false)
+	{}
+
+	LLCopyOnWritePointer(Type* ptr) 
+	:	LLPointer<Type>(ptr),
+		mStayUnique(false)
+	{}
+
+	LLCopyOnWritePointer(LLPointer<Type>& ptr)
+	:	LLPointer<Type>(ptr),
+		mStayUnique(false)
 	{
-		if( mPointer != ptr )
-		{
-			unref(); 
-			mPointer = ptr; 
-			ref();
-		}
-
-		return *this; 
-	}
-
-	LLConstPointer<Type>& operator =(const LLConstPointer<Type>& ptr)  
-	{ 
-		if( mPointer != ptr.mPointer )
+		if (ptr.mForceUnique)
 		{
-			unref(); 
-			mPointer = ptr.mPointer;
-			ref();
+			makeUnique();
 		}
-		return *this; 
 	}
 
-	// support assignment up the type hierarchy. See Item 45 in Effective C++, 3rd Ed.
-	template<typename Subclass>
-	LLConstPointer<Type>& operator =(const LLConstPointer<Subclass>& ptr)  
-	{ 
-		if( mPointer != ptr.get() )
-		{
-			unref(); 
-			mPointer = ptr.get();
-			ref();
-		}
-		return *this; 
-	}
-	
-	// Just exchange the pointers, which will not change the reference counts.
-	static void swap(LLConstPointer<Type>& a, LLConstPointer<Type>& b)
+	Type* write()
 	{
-		const Type* temp = a.mPointer;
-		a.mPointer = b.mPointer;
-		b.mPointer = temp;
+		makeUnique();
+		return pointer_t::mPointer;
 	}
 
-protected:
-#ifdef LL_LIBRARY_INCLUDE
-	void ref();                             
-	void unref();
-#else
-	void ref()                             
-	{ 
-		if (mPointer)
-		{
-			mPointer->ref();
-		}
-	}
-
-	void unref()
+	void makeUnique()
 	{
-		if (mPointer)
+		if (pointer_t::notNull() && pointer_t::mPointer->getNumRefs() > 1)
 		{
-			const Type *tempp = mPointer;
-			mPointer = NULL;
-			tempp->unref();
-			if (mPointer != NULL)
-			{
-				llwarns << "Unreference did assignment to non-NULL because of destructor" << llendl;
-				unref();
-			}
+			*(pointer_t* )(this) = new Type(*pointer_t::mPointer);
 		}
 	}
-#endif
-protected:
-	const Type*	mPointer;
+
+	const Type*	operator->() const	{ return pointer_t::mPointer; }
+	const Type&	operator*() const	{ return *pointer_t::mPointer; }
+
+	void setStayUnique(bool stay) { makeUnique(); mStayUnique = stay; }
+private:
+	bool mStayUnique;
 };
 
 #endif