1 files changed, 44 insertions, 46 deletions

diff --git a/linden/indra/llcommon/llmemory.h b/linden/indra/llcommon/llmemory.h
index 7a7996b..b6f42e3 100644
--- a/linden/indra/llcommon/llmemory.h
+++ b/linden/indra/llcommon/llmemory.h
@@ -4,6 +4,7 @@
  *
  * Copyright (c) 2002-2007, Linden Research, Inc.
  * 
+ * Second Life Viewer Source Code
  * The source code in this file ("Source Code") is provided by Linden Lab
  * to you under the terms of the GNU General Public License, version 2.0
  * ("GPL"), unless you have obtained a separate licensing agreement
@@ -193,6 +194,14 @@ public:
                 }
                 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:
         void ref()                             
@@ -239,29 +248,28 @@ class LLHandle
 {
 public:
         LLHandle() :
-                mPointer(sNullFunc())
+                mPointer(NULL)
         {
-                ref();
         }
 
         LLHandle(Type* ptr) : 
-                mPointer(nonNull(ptr))
+                mPointer(NULL)
         {
-                ref();
+                assign(ptr);
         }
 
         LLHandle(const LLHandle<Type>& ptr) : 
-                mPointer(ptr.mPointer)
+                mPointer(NULL)
         {
-                ref();
+                assign(ptr.mPointer);
         }
 
         // support conversion up the type hierarchy.  See Item 45 in Effective C++, 3rd Ed.
         template<typename Subclass>
         LLHandle(const LLHandle<Subclass>& ptr) : 
-                mPointer(ptr.get())
+                mPointer(NULL)
         {
-                ref();
+                assign(ptr.get());
         }
 
         ~LLHandle()                                                             
@@ -269,47 +277,39 @@ public:
                 unref();
         }
 
+        const Type*     operator->() const                              { return nonNull(mPointer); }
+        Type*   operator->()                                            { return nonNull(mPointer); }
+
         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; }
+        // 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 != sNullFunc()); }
-        operator bool()  const                                          { return (mPointer != sNullFunc()); }
-        bool operator!() const                                          { return (mPointer == sNullFunc()); }
-        bool isNull() const                                                     { return (mPointer == sNullFunc()); }
-        bool notNull() const                                            { return (mPointer != sNullFunc()); }
+        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 != nonNull(ptr));        }
-        bool operator ==(Type* ptr) const           { return (mPointer == nonNull(ptr));        }
+        bool operator !=(Type* ptr) const           { return (mPointer != ptr);         }
+        bool operator ==(Type* ptr) const           { return (mPointer == ptr);         }
         bool operator ==(const LLHandle<Type>& ptr) const           { return (mPointer == ptr.mPointer);        }
         bool operator < (const LLHandle<Type>& ptr) const           { return (mPointer < ptr.mPointer);         }
         bool operator > (const LLHandle<Type>& ptr) const           { return (mPointer > ptr.mPointer);         }
 
         LLHandle<Type>& operator =(Type* ptr)                   
         { 
-                if( mPointer != ptr )
-                {
-                        unref(); 
-                        mPointer = nonNull(ptr); 
-                        ref();
-                }
-
+                assign(ptr);
                 return *this; 
         }
 
         LLHandle<Type>& operator =(const LLHandle<Type>& ptr)  
         { 
-                if( mPointer != ptr.mPointer )
-                {
-                        unref(); 
-                        mPointer = ptr.mPointer;
-                        ref();
-                }
+                assign(ptr.mPointer);
                 return *this; 
         }
 
@@ -317,12 +317,7 @@ public:
         template<typename Subclass>
         LLHandle<Type>& operator =(const LLHandle<Subclass>& ptr)  
         { 
-                if( mPointer != ptr.get() )
-                {
-                        unref(); 
-                        mPointer = ptr.get();
-                        ref();
-                }
+                assign(ptr.get());
                 return *this; 
         }
 
@@ -344,9 +339,9 @@ protected:
                 if (mPointer)
                 {
                         Type *tempp = mPointer;
-                        mPointer = sNullFunc();
+                        mPointer = NULL;
                         tempp->unref();
-                        if (mPointer != sNullFunc())
+                        if (mPointer != NULL)
                         {
                                 llwarns << "Unreference did assignment to non-NULL because of destructor" << llendl;
                                 unref();
@@ -354,19 +349,22 @@ protected:
                 }
         }
 
-        static Type* nonNull(Type* ptr)
+        void assign(Type* ptr)
         {
-                return ptr == NULL ? sNullFunc() : ptr;
+                if( mPointer != ptr )
+                {
+                        unref(); 
+                        mPointer = ptr; 
+                        ref();
+                }
         }
 
-        static Type* defaultNullFunc()
+        static Type* nonNull(Type* ptr)
         {
-                llerrs << "No null value provided for LLHandle" << llendl;
-                return NULL;
+                return ptr == NULL ? sNullFunc() : ptr;
         }
 
 protected:
-
         Type*   mPointer;
 };