#824 Process source files in bulk: replace tabs with spaces, convert CRLF to LF, and trim trailing whitespaces as needed

1 files changed, 135 insertions, 135 deletions

diff --git a/indra/llcommon/llsafehandle.h b/indra/llcommon/llsafehandle.h
index 9550e6253e..1d7e4f8220 100644
--- a/indra/llcommon/llsafehandle.h
+++ b/indra/llcommon/llsafehandle.h
@@ -1,32 +1,32 @@
-/** 
+/**
  * @file llsafehandle.h
  * @brief Reference-counted object where Object() is valid, not NULL.
  *
  * $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 LLSAFEHANDLE_H
 #define LLSAFEHANDLE_H
 
-#include "llerror.h"	// *TODO: consider eliminating this
+#include "llerror.h"    // *TODO: consider eliminating this
 #include "llsingleton.h"
 
 /*==========================================================================*|
@@ -57,142 +57,142 @@ not ever affect subsequent computations.
 // when error checking occurs at a different granularity or in a different part of the code
 // than when referencing an object via a LLSafeHandle.
 
-template <class Type> 
+template <class Type>
 class LLSafeHandle
 {
 public:
-	LLSafeHandle() :
-		mPointer(NULL)
-	{
-	}
-
-	LLSafeHandle(Type* ptr) : 
-		mPointer(NULL)
-	{
-		assign(ptr);
-	}
-
-	LLSafeHandle(const LLSafeHandle<Type>& ptr) : 
-		mPointer(NULL)
-	{
-		assign(ptr.mPointer);
-	}
-
-	// support conversion up the type hierarchy.  See Item 45 in Effective C++, 3rd Ed.
-	template<typename Subclass>
-	LLSafeHandle(const LLSafeHandle<Subclass>& ptr) : 
-		mPointer(NULL)
-	{
-		assign(ptr.get());
-	}
-
-	~LLSafeHandle()								
-	{
-		unref();
-	}
-
-	const Type*	operator->() const				{ return nonNull(mPointer); }
-	Type*	operator->()						{ return nonNull(mPointer); }
-
-	Type*	get() const							{ return mPointer; }
-	void	clear()								{ assign(NULL); }
-	// we disallow these operations as they expose our null objects to direct manipulation
-	// and bypass the reference counting semantics
-	//const Type&	operator*() const			{ return *nonNull(mPointer); }
-	//Type&	operator*()							{ return *nonNull(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; }
-	operator const Type*() const				{ return mPointer; }
-	bool operator !=(Type* ptr) const           { return (mPointer != ptr); 	}
-	bool operator ==(Type* ptr) const           { return (mPointer == ptr); 	}
-	bool operator ==(const LLSafeHandle<Type>& ptr) const           { return (mPointer == ptr.mPointer); 	}
-	bool operator < (const LLSafeHandle<Type>& ptr) const           { return (mPointer < ptr.mPointer); 	}
-	bool operator > (const LLSafeHandle<Type>& ptr) const           { return (mPointer > ptr.mPointer); 	}
-
-	LLSafeHandle<Type>& operator =(Type* ptr)                   
-	{ 
-		assign(ptr);
-		return *this; 
-	}
-
-	LLSafeHandle<Type>& operator =(const LLSafeHandle<Type>& ptr)  
-	{ 
-		assign(ptr.mPointer);
-		return *this; 
-	}
-
-	// support assignment up the type hierarchy. See Item 45 in Effective C++, 3rd Ed.
-	template<typename Subclass>
-	LLSafeHandle<Type>& operator =(const LLSafeHandle<Subclass>& ptr)  
-	{ 
-		assign(ptr.get());
-		return *this; 
-	}
+    LLSafeHandle() :
+        mPointer(NULL)
+    {
+    }
+
+    LLSafeHandle(Type* ptr) :
+        mPointer(NULL)
+    {
+        assign(ptr);
+    }
+
+    LLSafeHandle(const LLSafeHandle<Type>& ptr) :
+        mPointer(NULL)
+    {
+        assign(ptr.mPointer);
+    }
+
+    // support conversion up the type hierarchy.  See Item 45 in Effective C++, 3rd Ed.
+    template<typename Subclass>
+    LLSafeHandle(const LLSafeHandle<Subclass>& ptr) :
+        mPointer(NULL)
+    {
+        assign(ptr.get());
+    }
+
+    ~LLSafeHandle()
+    {
+        unref();
+    }
+
+    const Type* operator->() const              { return nonNull(mPointer); }
+    Type*   operator->()                        { return nonNull(mPointer); }
+
+    Type*   get() const                         { return mPointer; }
+    void    clear()                             { assign(NULL); }
+    // we disallow these operations as they expose our null objects to direct manipulation
+    // and bypass the reference counting semantics
+    //const Type&   operator*() const           { return *nonNull(mPointer); }
+    //Type& operator*()                         { return *nonNull(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; }
+    operator const Type*() const                { return mPointer; }
+    bool operator !=(Type* ptr) const           { return (mPointer != ptr);     }
+    bool operator ==(Type* ptr) const           { return (mPointer == ptr);     }
+    bool operator ==(const LLSafeHandle<Type>& ptr) const           { return (mPointer == ptr.mPointer);    }
+    bool operator < (const LLSafeHandle<Type>& ptr) const           { return (mPointer < ptr.mPointer);     }
+    bool operator > (const LLSafeHandle<Type>& ptr) const           { return (mPointer > ptr.mPointer);     }
+
+    LLSafeHandle<Type>& operator =(Type* ptr)
+    {
+        assign(ptr);
+        return *this;
+    }
+
+    LLSafeHandle<Type>& operator =(const LLSafeHandle<Type>& ptr)
+    {
+        assign(ptr.mPointer);
+        return *this;
+    }
+
+    // support assignment up the type hierarchy. See Item 45 in Effective C++, 3rd Ed.
+    template<typename Subclass>
+    LLSafeHandle<Type>& operator =(const LLSafeHandle<Subclass>& ptr)
+    {
+        assign(ptr.get());
+        return *this;
+    }
 
 protected:
-	void ref()                             
-	{ 
-		if (mPointer)
-		{
-			mPointer->ref();
-		}
-	}
-
-	void unref()
-	{
-		if (mPointer)
-		{
-			Type *tempp = mPointer;
-			mPointer = NULL;
-			tempp->unref();
-			if (mPointer != NULL)
-			{
-				LL_WARNS() << "Unreference did assignment to non-NULL because of destructor" << LL_ENDL;
-				unref();
-			}
-		}
-	}
-
-	void assign(Type* ptr)
-	{
-		if( mPointer != ptr )
-		{
-			unref(); 
-			mPointer = ptr; 
-			ref();
-		}
-	}
-
-	// Define an LLSingleton whose sole purpose is to hold a "null instance"
-	// of the subject Type: the canonical instance to dereference if this
-	// LLSafeHandle actually holds a null pointer. We use LLSingleton
-	// specifically so that the "null instance" can be cleaned up at a well-
-	// defined time, specifically LLSingletonBase::deleteAll().
-	// Of course, as with any LLSingleton, the "null instance" is only
-	// instantiated on demand -- in this case, if you actually try to
-	// dereference an LLSafeHandle containing null.
-	class NullInstanceHolder: public LLSingleton<NullInstanceHolder>
-	{
-		LLSINGLETON_EMPTY_CTOR(NullInstanceHolder);
-		~NullInstanceHolder() {}
-	public:
-		Type mNullInstance;
-	};
-
-	static Type* nonNull(Type* ptr)
-	{
-		return ptr? ptr : &NullInstanceHolder::instance().mNullInstance;
-	}
+    void ref()
+    {
+        if (mPointer)
+        {
+            mPointer->ref();
+        }
+    }
+
+    void unref()
+    {
+        if (mPointer)
+        {
+            Type *tempp = mPointer;
+            mPointer = NULL;
+            tempp->unref();
+            if (mPointer != NULL)
+            {
+                LL_WARNS() << "Unreference did assignment to non-NULL because of destructor" << LL_ENDL;
+                unref();
+            }
+        }
+    }
+
+    void assign(Type* ptr)
+    {
+        if( mPointer != ptr )
+        {
+            unref();
+            mPointer = ptr;
+            ref();
+        }
+    }
+
+    // Define an LLSingleton whose sole purpose is to hold a "null instance"
+    // of the subject Type: the canonical instance to dereference if this
+    // LLSafeHandle actually holds a null pointer. We use LLSingleton
+    // specifically so that the "null instance" can be cleaned up at a well-
+    // defined time, specifically LLSingletonBase::deleteAll().
+    // Of course, as with any LLSingleton, the "null instance" is only
+    // instantiated on demand -- in this case, if you actually try to
+    // dereference an LLSafeHandle containing null.
+    class NullInstanceHolder: public LLSingleton<NullInstanceHolder>
+    {
+        LLSINGLETON_EMPTY_CTOR(NullInstanceHolder);
+        ~NullInstanceHolder() {}
+    public:
+        Type mNullInstance;
+    };
+
+    static Type* nonNull(Type* ptr)
+    {
+        return ptr? ptr : &NullInstanceHolder::instance().mNullInstance;
+    }
 
 protected:
-	Type*	mPointer;
+    Type*   mPointer;
 };
 
 #endif