Changeset 11763 in webkit for trunk/JavaScriptCore/kxmlcore/RefPtr.h

Timestamp:

Dec 25, 2005, 1:22:35 AM (19 years ago)

Author:

mjs

Message:

Reviewed by Eric and Dave Hyatt.

• make even const PassRefPtrs give transfer of ownership semantics ​http://bugzilla.opendarwin.org/show_bug.cgi?id=6238

This is a somewhat cheesy change. Having to use PassRefPtr_Ref creates ambiguities
in assignment and copy construction. And this makes life way easier and removes
the need for pass(). It is not really correct, but we pretty much never need a real
const PassRefPtr, and this takes care of things for PassRefPtr temporaries.

• kjs/identifier.cpp: (KJS::Identifier::add): No more need for pass()
• kjs/property_map.cpp: (KJS::PropertyMap::addSparseArrayPropertiesToReferenceList): No more need for pass()
• kjs/ustring.cpp: (KJS::UString::Rep::create): Use adoptRef (KJS::UString::UString): No more need for pass (KJS::UString::append): No more need for pass (KJS::UString::substr): No more need for pass
• kxmlcore/PassRefPtr.h: made m_ptr mutable (ugh) (KXMLCore::PassRefPtr::PassRefPtr): Take a const PassRefPtr reference (KXMLCore::PassRefPtr::release): Made this a const method (ugh) (KXMLCore::PassRefPtr::operator=): clean up appropriately (KXMLCore::adoptRef): Added this to use instead of PassRefPtr<T>::adopt, I think it makes the behavior more clear and it is less verbose. (KXMLCore::static_pointer_cast): use adoptRef (KXMLCore::const_pointer_cast): use adoptRef
• kxmlcore/RefPtr.h: (KXMLCore::RefPtr::RefPtr): take const PassRefPtr& (KXMLCore::PassRefPtr::operator=): take const PassRefPtr&

File:

• trunk/JavaScriptCore/kxmlcore/RefPtr.h (modified) (6 diffs)

trunk/JavaScriptCore/kxmlcore/RefPtr.h

@@ -29 +29 @@
 
     template <typename T> class PassRefPtr;
-    template <typename T> class PassRefPtr_Ref;
 
     template <typename T> class RefPtr
@@ -37 +36 @@
         RefPtr(T *ptr) : m_ptr(ptr) { if (ptr) ptr->ref(); }
         RefPtr(const RefPtr& o) : m_ptr(o.m_ptr) { if (T *ptr = m_ptr) ptr->ref(); }
-        template <typename U> RefPtr(PassRefPtr<U>&);
-        template <typename U> RefPtr(PassRefPtr_Ref<U>);
+        // see comment in PassRefPtr.h for why this takes const reference
+        template <typename U> RefPtr(const PassRefPtr<U>&);
 
         ~RefPtr() { if (T *ptr = m_ptr) ptr->deref(); }
@@ -57 +56 @@
         RefPtr& operator=(const RefPtr&);
         RefPtr& operator=(T *);
-        RefPtr& operator=(PassRefPtr<T>&);
-        RefPtr& operator=(PassRefPtr_Ref<T>);
+        RefPtr& operator=(const PassRefPtr<T>&);
         template <typename U> RefPtr& operator=(const RefPtr<U>&);
-        template <typename U> RefPtr& operator=(PassRefPtr<U>&);
-        template <typename U> RefPtr& operator=(PassRefPtr_Ref<U>);
+        template <typename U> RefPtr& operator=(const PassRefPtr<U>&);
 
         void swap(RefPtr&);
@@ -69 +66 @@
     };
     
-    template <typename T> template <typename U> inline RefPtr<T>::RefPtr(PassRefPtr_Ref<U> ref)
-        : m_ptr(ref.m_ptr)
-    {
-    }
-    
-    template <typename T> template <typename U> inline RefPtr<T>::RefPtr(PassRefPtr<U>& o)
+    template <typename T> template <typename U> inline RefPtr<T>::RefPtr(const PassRefPtr<U>& o)
         : m_ptr(o.release())
     {
@@ -111 +103 @@
     }
 
-    template <typename T> template <typename U> inline RefPtr<T>& RefPtr<T>::operator=(PassRefPtr_Ref<U> ref)
-    {
-        if (m_ptr)
-            m_ptr->deref();
-        m_ptr = ref.m_ptr;
-        return *this;
-    }
-    
-    template <typename T> inline RefPtr<T>& RefPtr<T>::operator=(PassRefPtr<T>& o)
+    template <typename T> inline RefPtr<T>& RefPtr<T>::operator=(const PassRefPtr<T>& o)
     {
         if (m_ptr)
@@ -127 +111 @@
     }
 
-    template <typename T> inline RefPtr<T>& RefPtr<T>::operator=(PassRefPtr_Ref<T> ref)
-    {
-        if (m_ptr)
-            m_ptr->deref();
-        m_ptr = ref.m_ptr;
-        return *this;
-    }
-    
-    template <typename T> template <typename U> inline RefPtr<T>& RefPtr<T>::operator=(PassRefPtr<U>& o)
+    template <typename T> template <typename U> inline RefPtr<T>& RefPtr<T>::operator=(const PassRefPtr<U>& o)
     {
         if (m_ptr)