Changeset 157049 in webkit

Timestamp:

Oct 7, 2013 11:07:54 AM (11 years ago)

Author:

andersca@apple.com

Message:

Remove passIn and passOut from HashTraits
​https://bugs.webkit.org/show_bug.cgi?id=122452

Reviewed by Sam Weinig.

Change RefPtrHashMap to not use passOut (just like the regular HashMap) and get rid of the
passIn and passOut functions and related typedefs.

• wtf/HashTraits.h:
• wtf/RefPtrHashMap.h:

Location:

trunk/Source/WTF

Files:

• ChangeLog (modified) (1 diff)
• wtf/HashTraits.h (modified) (2 diffs)
• wtf/RefPtrHashMap.h (modified) (3 diffs)

trunk/Source/WTF/ChangeLog

@@ +1 @@
+2013-10-07  Anders Carlsson  <andersca@apple.com>
+
+        Remove passIn and passOut from HashTraits
+        https://bugs.webkit.org/show_bug.cgi?id=122452
+
+        Reviewed by Sam Weinig.
+
+        Change RefPtrHashMap to not use passOut (just like the regular HashMap) and get rid of the
+        passIn and passOut functions and related typedefs.
+
+        * wtf/HashTraits.h:
+        * wtf/RefPtrHashMap.h:
+
 2013-10-06  Anders Carlsson  <andersca@apple.com>
 

trunk/Source/WTF/wtf/HashTraits.h

@@ -65 +65 @@
     static T emptyValue() { return T(); }
 
-    // Type for functions that take ownership, such as add.
-    // The store function either not be called or called once to store something passed in.
-    // The value passed to the store function will be either PassInType or PassInType&.
-    typedef const T& PassInType;
-    static void store(const T& value, T& storage) { storage = value; }
-
-    // Type for return value of functions that transfer ownership, such as take. 
-    typedef T PassOutType;
-    static PassOutType passOut(const T& value) { return value; }
-    static T& passOut(T& value) { return value; } // Overloaded to avoid copying of non-temporary values.
-
     // Type for return value of functions that do not transfer ownership, such as get.
-    // FIXME: We could change this type to const T& for better performance if we figured out
-    // a way to handle the return value from emptyValue, which is a temporary.
     typedef T PeekType;
     static PeekType peek(const T& value) { return value; }
@@ -136 +123 @@
     static P* emptyValue() { return 0; }
 
-    typedef PassRefPtr<P> PassInType;
-    static void store(PassRefPtr<P> value, RefPtr<P>& storage) { storage = value; }
-
-    typedef PassRefPtr<P> PassOutType;
-    static PassRefPtr<P> passOut(RefPtr<P>& value) { return value.release(); }
-    static PassRefPtr<P> passOut(P* value) { return value; }
-
     typedef P* PeekType;
     static PeekType peek(const RefPtr<P>& value) { return value.get(); }

trunk/Source/WTF/wtf/RefPtrHashMap.h

@@ -44 +44 @@
 
     private:
-        typedef typename MappedTraits::PassInType MappedPassInType;
-        typedef typename MappedTraits::PassOutType MappedPassOutType;
         typedef typename MappedTraits::PeekType MappedPeekType;
-
-        typedef typename std::add_lvalue_reference<MappedPassInType>::type MappedPassInReferenceType;
         
         typedef HashArg HashFunctions;
@@ -102 +98 @@
         void clear();
 
-        MappedPassOutType take(const KeyType&); // efficient combination of get with remove
-        MappedPassOutType take(RawKeyType); // efficient combination of get with remove
+        MappedType take(const KeyType&); // efficient combination of get with remove
+        MappedType take(RawKeyType); // efficient combination of get with remove
 
     private:
@@ -307 +303 @@
 
     template<typename T, typename U, typename V, typename W, typename MappedTraits>
-    typename HashMap<RefPtr<T>, U, V, W, MappedTraits>::MappedPassOutType
-    HashMap<RefPtr<T>, U, V, W, MappedTraits>::take(const KeyType& key)
+    auto HashMap<RefPtr<T>, U, V, W, MappedTraits>::take(const KeyType& key) -> MappedType
     {
         iterator it = find(key);
         if (it == end())
-            return MappedTraits::passOut(MappedTraits::emptyValue());
-        MappedPassOutType result = MappedTraits::passOut(it->value);
+            return MappedTraits::emptyValue();
+        MappedType value = std::move(it->value);
         remove(it);
-        return result;
-    }
-
-    template<typename T, typename U, typename V, typename W, typename MappedTraits>
-    typename HashMap<RefPtr<T>, U, V, W, MappedTraits>::MappedPassOutType
-    HashMap<RefPtr<T>, U, V, W, MappedTraits>::take(RawKeyType key)
+        return value;
+    }
+
+    template<typename T, typename U, typename V, typename W, typename MappedTraits>
+    auto HashMap<RefPtr<T>, U, V, W, MappedTraits>::take(RawKeyType key) -> MappedType
     {
         iterator it = find(key);
         if (it == end())
-            return MappedTraits::passOut(MappedTraits::emptyValue());
-        MappedPassOutType result = MappedTraits::passOut(it->value);
+            return MappedTraits::emptyValue();
+        MappedType value = std::move(it->value);
         remove(it);
-        return result;
+        return value;
     }