Changeset 11763 in webkit for trunk/JavaScriptCore/kxmlcore/PassRefPtr.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/PassRefPtr.h (modified) (8 diffs)

trunk/JavaScriptCore/kxmlcore/PassRefPtr.h

@@ -28 +28 @@
     template<typename T> class RefPtr;
     template<typename T> class PassRefPtr;
-
-    // PassRefPtr_Ref class is a helper to allow proper passing of PassRefPtr by value but not by const
-    // reference
-    template<typename T> 
-    struct PassRefPtr_Ref
-    {
-        T* m_ptr;
-        explicit PassRefPtr_Ref(T* p) : m_ptr(p) {}
-    };
+    template <typename T> PassRefPtr<T> adoptRef(T *p);
 
     template<typename T> 
@@ -44 +36 @@
         PassRefPtr() : m_ptr(0) {}
         PassRefPtr(T *ptr) : m_ptr(ptr) { if (ptr) ptr->ref(); }
-        PassRefPtr(PassRefPtr& o) : m_ptr(o.release()) {}
-        template <typename U> PassRefPtr(PassRefPtr<U>& o) : m_ptr(o.release()) { }
+        // It somewhat breaks the type system to allow transfer of ownership out of
+        // a const PassRefPtr. However, it makes it much easier to work with PassRefPtr
+        // temporaries, and we don't really have a need to use real const PassRefPtrs 
+        // anyway.
+        PassRefPtr(const PassRefPtr& o) : m_ptr(o.release()) {}
+        template <typename U> PassRefPtr(const PassRefPtr<U>& o) : m_ptr(o.release()) { }
 
         ~PassRefPtr() { if (T *ptr = m_ptr) ptr->deref(); }
@@ -54 +50 @@
         T *get() const { return m_ptr; }
 
-        T *release() { T *tmp = m_ptr; m_ptr = 0; return tmp; }
+        T *release() const { T *tmp = m_ptr; m_ptr = 0; return tmp; }
 
-        template <typename U> static PassRefPtr<T> adopt(U* ptr)
-        {
-            PassRefPtr result((PassRefPtr_Ref<T>(ptr)));
-            return result;
-        }
-        
         T& operator*() const { return *m_ptr; }
         T *operator->() const { return m_ptr; }
@@ -72 +62 @@
         
         PassRefPtr& operator=(T *);
-        PassRefPtr& operator=(PassRefPtr&);
-        template <typename U> PassRefPtr& operator=(PassRefPtr<U>&);
+        PassRefPtr& operator=(const PassRefPtr&);
+        template <typename U> PassRefPtr& operator=(const PassRefPtr<U>&);
         template <typename U> PassRefPtr& operator=(const RefPtr<U>&);
 
-        PassRefPtr(PassRefPtr_Ref<T> ref) : m_ptr(ref.m_ptr) { }
-      
-        PassRefPtr& operator=(PassRefPtr_Ref<T> ref)
-        {
-            if (m_ptr)
-                m_ptr->deref();
-            m_ptr = ref.m_ptr;
-            return *this;
-        }
-
-        template <typename U> operator PassRefPtr_Ref<U>() { return PassRefPtr_Ref<U>(release()); }
-        template <typename U> operator PassRefPtr<U>() { return PassRefPtr_Ref<U>(release()); }
-        
+        friend PassRefPtr adoptRef<T>(T *);
     private:
-        T *m_ptr;
+        // adopting constructor
+        PassRefPtr(T *ptr, bool) : m_ptr(ptr) {}
+        mutable T *m_ptr;
     };
     
@@ -114 +94 @@
     }
 
-    template <typename T> inline PassRefPtr<T>& PassRefPtr<T>::operator=(PassRefPtr<T>& ref)
+    template <typename T> inline PassRefPtr<T>& PassRefPtr<T>::operator=(const PassRefPtr<T>& ref)
     {
         T *optr = ref.release();
@@ -123 +103 @@
     }
     
-    template <typename T> template <typename U> inline PassRefPtr<T>& PassRefPtr<T>::operator=(PassRefPtr<U>& ref)
+    template <typename T> template <typename U> inline PassRefPtr<T>& PassRefPtr<T>::operator=(const PassRefPtr<U>& ref)
     {
         T *optr = ref.release();
@@ -182 +162 @@
     }
     
+    template <typename T> inline PassRefPtr<T> adoptRef(T *p)
+    {
+        return PassRefPtr<T>(p, true);
+    }
+
     template <typename T, typename U> inline PassRefPtr<T> static_pointer_cast(const PassRefPtr<U>& p) 
     { 
-        return PassRefPtr<T>::adopt(static_cast<T *>(p.release())); 
+        return adoptRef(static_cast<T *>(p.release())); 
     }
 
     template <typename T, typename U> inline PassRefPtr<T> const_pointer_cast(const PassRefPtr<U>& p) 
     { 
-        return PassRefPtr<T>::adopt(const_cast<T *>(p.release())); 
-    }
-
-    template <typename T> inline PassRefPtr<T> pass(T *ptr)
-    {
-        return PassRefPtr<T>(ptr);
-    }
-
-    template <typename T> inline PassRefPtr<T> pass(const RefPtr<T>& ptr)
-    {
-        return PassRefPtr<T>(ptr);
+        return adoptRef(const_cast<T *>(p.release())); 
     }
 
@@ -205 +180 @@
 
 using KXMLCore::PassRefPtr;
+using KXMLCore::adoptRef;
 using KXMLCore::static_pointer_cast;
 using KXMLCore::const_pointer_cast;
-using KXMLCore::pass;
 
 #endif // KXMLCORE_PASS_REF_PTR_H