Merge DRTVWR-591-maint-X to main on promotion of secondlife/viewer #705: Maintenance X

1 files changed, 272 insertions, 272 deletions

diff --git a/indra/llcommon/llpointer.h b/indra/llcommon/llpointer.h
index 64aceddf32..f5916f9d58 100644
--- a/indra/llcommon/llpointer.h
+++ b/indra/llcommon/llpointer.h
@@ -1,32 +1,32 @@
-/** 
+/**
  * @file llpointer.h
  * @brief A reference-counted pointer for objects derived from LLRefCount
  *
  * $LicenseInfo:firstyear=2002&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
 #ifndef LLPOINTER_H
 #define LLPOINTER_H
 
-#include "llerror.h"	// *TODO: consider eliminating this
+#include "llerror.h"    // *TODO: consider eliminating this
 #include "llmutex.h"
 
 //----------------------------------------------------------------------------
@@ -46,299 +46,299 @@
 template <class Type> class LLPointer
 {
 public:
-	LLPointer() :
-		mPointer(NULL)
-	{
-	}
-
-	LLPointer(Type* ptr) :
-		mPointer(ptr)
-	{
-		ref();
-	}
-
-	LLPointer(const LLPointer<Type>& ptr) :
-		mPointer(ptr.mPointer)
-	{
-		ref();
-	}
-
-	// Support conversion up the type hierarchy. See Item 45 in Effective C++, 3rd Ed.
-	template<typename Subclass>
-	LLPointer(const LLPointer<Subclass>& ptr) :
-		mPointer(ptr.get())
-	{
-		ref();
-	}
-
-	~LLPointer()
-	{
-		unref();
-	}
-
-	Type*	get() const							{ return mPointer; }
-	const Type*	operator->() const				{ return mPointer; }
-	Type*	operator->()						{ return mPointer; }
-	const Type&	operator*() const				{ return *mPointer; }
-	Type&	operator*()							{ 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 Type*() const						{ return mPointer; }
-	bool operator !=(Type* ptr) const			{ return (mPointer != ptr); }
-	bool operator ==(Type* ptr) const			{ return (mPointer == ptr); }
-	bool operator ==(const LLPointer<Type>& ptr) const { return (mPointer == ptr.mPointer); }
-	bool operator < (const LLPointer<Type>& ptr) const { return (mPointer < ptr.mPointer); }
-	bool operator > (const LLPointer<Type>& ptr) const { return (mPointer > ptr.mPointer); }
-
-	LLPointer<Type>& operator =(Type* ptr)
-	{
-		assign(ptr);
-		return *this;
-	}
-
-	LLPointer<Type>& operator =(const LLPointer<Type>& ptr)
-	{
-		assign(ptr);
-		return *this;
-	}
-
-	// support assignment up the type hierarchy. See Item 45 in Effective C++, 3rd Ed.
-	template<typename Subclass>
-	LLPointer<Type>& operator =(const LLPointer<Subclass>& ptr)
-	{
-		assign(ptr.get());
-		return *this;
-	}
-
-	// Just exchange the pointers, which will not change the reference counts.
-	static void swap(LLPointer<Type>& a, LLPointer<Type>& b)
-	{
-		Type* temp = a.mPointer;
-		a.mPointer = b.mPointer;
-		b.mPointer = temp;
-	}
+    LLPointer() :
+        mPointer(NULL)
+    {
+    }
+
+    LLPointer(Type* ptr) :
+        mPointer(ptr)
+    {
+        ref();
+    }
+
+    LLPointer(const LLPointer<Type>& ptr) :
+        mPointer(ptr.mPointer)
+    {
+        ref();
+    }
+
+    // Support conversion up the type hierarchy. See Item 45 in Effective C++, 3rd Ed.
+    template<typename Subclass>
+    LLPointer(const LLPointer<Subclass>& ptr) :
+        mPointer(ptr.get())
+    {
+        ref();
+    }
+
+    ~LLPointer()
+    {
+        unref();
+    }
+
+    Type*   get() const                         { return mPointer; }
+    const Type* operator->() const              { return mPointer; }
+    Type*   operator->()                        { return mPointer; }
+    const Type& operator*() const               { return *mPointer; }
+    Type&   operator*()                         { 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 Type*() const                      { return mPointer; }
+    bool operator !=(Type* ptr) const           { return (mPointer != ptr); }
+    bool operator ==(Type* ptr) const           { return (mPointer == ptr); }
+    bool operator ==(const LLPointer<Type>& ptr) const { return (mPointer == ptr.mPointer); }
+    bool operator < (const LLPointer<Type>& ptr) const { return (mPointer < ptr.mPointer); }
+    bool operator > (const LLPointer<Type>& ptr) const { return (mPointer > ptr.mPointer); }
+
+    LLPointer<Type>& operator =(Type* ptr)
+    {
+        assign(ptr);
+        return *this;
+    }
+
+    LLPointer<Type>& operator =(const LLPointer<Type>& ptr)
+    {
+        assign(ptr);
+        return *this;
+    }
+
+    // support assignment up the type hierarchy. See Item 45 in Effective C++, 3rd Ed.
+    template<typename Subclass>
+    LLPointer<Type>& operator =(const LLPointer<Subclass>& ptr)
+    {
+        assign(ptr.get());
+        return *this;
+    }
+
+    // Just exchange the pointers, which will not change the reference counts.
+    static void swap(LLPointer<Type>& a, LLPointer<Type>& b)
+    {
+        Type* temp = a.mPointer;
+        a.mPointer = b.mPointer;
+        b.mPointer = temp;
+    }
 
 protected:
 #ifdef LL_LIBRARY_INCLUDE
-	void ref();                             
-	void unref();
+    void ref();
+    void unref();
 #else
-	void ref()                             
-	{ 
-		if (mPointer)
-		{
-			mPointer->ref();
-		}
-	}
-
-	void unref()
-	{
-		if (mPointer)
-		{
-			Type *temp = mPointer;
-			mPointer = NULL;
-			temp->unref();
-			if (mPointer != NULL)
-			{
-				LL_WARNS() << "Unreference did assignment to non-NULL because of destructor" << LL_ENDL;
-				unref();
-			}
-		}
-	}
+    void ref()
+    {
+        if (mPointer)
+        {
+            mPointer->ref();
+        }
+    }
+
+    void unref()
+    {
+        if (mPointer)
+        {
+            Type *temp = mPointer;
+            mPointer = NULL;
+            temp->unref();
+            if (mPointer != NULL)
+            {
+                LL_WARNS() << "Unreference did assignment to non-NULL because of destructor" << LL_ENDL;
+                unref();
+            }
+        }
+    }
 #endif // LL_LIBRARY_INCLUDE
 
-	void assign(const LLPointer<Type>& ptr)
-	{
-		if (mPointer != ptr.mPointer)
-		{
-			unref();
-			mPointer = ptr.mPointer;
-			ref();
-		}
-	}
+    void assign(const LLPointer<Type>& ptr)
+    {
+        if (mPointer != ptr.mPointer)
+        {
+            unref();
+            mPointer = ptr.mPointer;
+            ref();
+        }
+    }
 
 protected:
-	Type*	mPointer;
+    Type*   mPointer;
 };
 
 template <class Type> class LLConstPointer
 {
 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)
-	{
-		if( mPointer != ptr )
-		{
-			unref();
-			mPointer = ptr;
-			ref();
-		}
-
-		return *this;
-	}
-
-	LLConstPointer<Type>& operator =(const LLConstPointer<Type>& ptr)
-	{
-		if( mPointer != ptr.mPointer )
-		{
-			unref();
-			mPointer = ptr.mPointer;
-			ref();
-		}
-		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)
-	{
-		const Type* temp = a.mPointer;
-		a.mPointer = b.mPointer;
-		b.mPointer = temp;
-	}
+    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)
+    {
+        if( mPointer != ptr )
+        {
+            unref();
+            mPointer = ptr;
+            ref();
+        }
+
+        return *this;
+    }
+
+    LLConstPointer<Type>& operator =(const LLConstPointer<Type>& ptr)
+    {
+        if( mPointer != ptr.mPointer )
+        {
+            unref();
+            mPointer = ptr.mPointer;
+            ref();
+        }
+        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)
+    {
+        const Type* temp = a.mPointer;
+        a.mPointer = b.mPointer;
+        b.mPointer = temp;
+    }
 
 protected:
 #ifdef LL_LIBRARY_INCLUDE
-	void ref();
-	void unref();
+    void ref();
+    void unref();
 #else // LL_LIBRARY_INCLUDE
-	void ref()
-	{
-		if (mPointer)
-		{
-			mPointer->ref();
-		}
-	}
-
-	void unref()
-	{
-		if (mPointer)
-		{
-			const Type *temp = mPointer;
-			mPointer = NULL;
-			temp->unref();
-			if (mPointer != NULL)
-			{
-				LL_WARNS() << "Unreference did assignment to non-NULL because of destructor" << LL_ENDL;
-				unref();
-			}
-		}
-	}
+    void ref()
+    {
+        if (mPointer)
+        {
+            mPointer->ref();
+        }
+    }
+
+    void unref()
+    {
+        if (mPointer)
+        {
+            const Type *temp = mPointer;
+            mPointer = NULL;
+            temp->unref();
+            if (mPointer != NULL)
+            {
+                LL_WARNS() << "Unreference did assignment to non-NULL because of destructor" << LL_ENDL;
+                unref();
+            }
+        }
+    }
 #endif // LL_LIBRARY_INCLUDE
 
 protected:
-	const Type*	mPointer;
+    const Type* mPointer;
 };
 
 template<typename Type>
 class LLCopyOnWritePointer : public LLPointer<Type>
 {
 public:
-	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 (ptr.mForceUnique)
-		{
-			makeUnique();
-		}
-	}
-
-	Type* write()
-	{
-		makeUnique();
-		return pointer_t::mPointer;
-	}
-
-	void makeUnique()
-	{
-		if (pointer_t::notNull() && pointer_t::mPointer->getNumRefs() > 1)
-		{
-			*(pointer_t* )(this) = new Type(*pointer_t::mPointer);
-		}
-	}
-
-	const Type*	operator->() const	{ return pointer_t::mPointer; }
-	const Type&	operator*() const	{ return *pointer_t::mPointer; }
-
-	void setStayUnique(bool stay) { makeUnique(); mStayUnique = stay; }
+    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 (ptr.mForceUnique)
+        {
+            makeUnique();
+        }
+    }
+
+    Type* write()
+    {
+        makeUnique();
+        return pointer_t::mPointer;
+    }
+
+    void makeUnique()
+    {
+        if (pointer_t::notNull() && pointer_t::mPointer->getNumRefs() > 1)
+        {
+            *(pointer_t* )(this) = new Type(*pointer_t::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;
+    bool mStayUnique;
 };