Changeset 32650 in webkit for trunk/JavaScriptCore/wtf/RefPtrHashMap.h

Timestamp:

Apr 28, 2008, 10:18:15 AM (17 years ago)

Author:

Darin Adler

Message:

2008-04-28 Darin Adler <Darin Adler>

Reviewed by Adam.

• make sure RefPtr's default hash doesn't ref/deref when computing the hash
• remove remnants of the hash table storage type optimization

• wtf/HashFunctions.h: Used "using" to get the hash and equal functions from PtrHash<P*> into PtrHash<RefPtr<P>>.

• wtf/HashMap.h: Replaced uses of PairBaseHashTraits with PairHashTraits. Eliminated storage-related typedefs. Removed constructor, destructor, copy constructor, and destructor since the compiler-generated ones are fine. Removed refAll and derefAll. Took out unnnecessary typecasts. Removed use of RefCounter.

• wtf/HashSet.h: Eliminated storage-related typedefs. Removed constructor, destructor, copy constructor, and destructor since the compiler-generated ones are fine. Removed refAll and derefAll. Removed unneeded template arguents from HashSetTranslatorAdapter. Eliminated unneeded HashSetTranslator template.

• wtf/HashTable.h: Tweaked formatting. Removed NeedsRef, RefCounterBase, RefCounter, HashTableRefCounterBase, HashTableRefCounter, and Assigner class templates.

• wtf/HashTraits.h: Removed StorageTraits, needsRef, PairBaseHashTraits, and HashKeyStorageTraits.

• wtf/RefPtrHashMap.h: Made all the same fixes as in HashMap. Also made the corresponding changes to RefPtrHashMapRawKeyTranslator.

File:

• trunk/JavaScriptCore/wtf/RefPtrHashMap.h (modified) (13 diffs)

trunk/JavaScriptCore/wtf/RefPtrHashMap.h

@@ -25 +25 @@
     // to allow for lookup by pointer instead of RefPtr, avoiding ref-count churn.
     
-    // FIXME: Is there a better way to do this that doesn't just copy HashMap?
+    // FIXME: Find a better way that doesn't require an entire copy of the HashMap template.
     
-    template<typename RawKeyType, typename ValueType, typename ValueTraits, typename ValueStorageTraits, typename HashFunctions>
+    template<typename RawKeyType, typename ValueType, typename ValueTraits, typename HashFunctions>
     struct RefPtrHashMapRawKeyTranslator {
         typedef typename ValueType::first_type KeyType;
         typedef typename ValueType::second_type MappedType;
-        typedef typename ValueStorageTraits::TraitType ValueStorageType;
-        typedef typename ValueStorageTraits::FirstTraits KeyStorageTraits;
-        typedef typename KeyStorageTraits::TraitType KeyStorageType;
-        typedef typename ValueStorageTraits::SecondTraits MappedStorageTraits;
-        typedef typename MappedStorageTraits::TraitType MappedStorageType;
         typedef typename ValueTraits::FirstTraits KeyTraits;
         typedef typename ValueTraits::SecondTraits MappedTraits;
 
         static unsigned hash(RawKeyType key) { return HashFunctions::hash(key); }
-        static bool equal(const KeyStorageType& a, RawKeyType b) { return HashFunctions::equal(*(KeyType*)&a, b); }
-        static void translate(ValueStorageType& location, RawKeyType key, const MappedType& mapped)
+        static bool equal(const KeyType& a, RawKeyType b) { return HashFunctions::equal(a, b); }
+        static void translate(ValueType& location, RawKeyType key, const MappedType& mapped)
         {
             location.first = key;
@@ -53 +48 @@
         typedef KeyTraitsArg KeyTraits;
         typedef MappedTraitsArg MappedTraits;
-        typedef PairBaseHashTraits<KeyTraits, MappedTraits> ValueTraits;
+        typedef PairHashTraits<KeyTraits, MappedTraits> ValueTraits;
 
     public:
@@ -64 +59 @@
         typedef HashArg HashFunctions;
 
-        typedef typename HashKeyStorageTraits<HashFunctions, KeyTraits>::Hash StorageHashFunctions;
-
-        typedef typename HashKeyStorageTraits<HashFunctions, KeyTraits>::Traits KeyStorageTraits;
-        typedef typename MappedTraits::StorageTraits MappedStorageTraits;
-        typedef PairHashTraits<KeyStorageTraits, MappedStorageTraits> ValueStorageTraits;
-
-        typedef typename KeyStorageTraits::TraitType KeyStorageType;
-        typedef typename MappedStorageTraits::TraitType MappedStorageType;
-        typedef typename ValueStorageTraits::TraitType ValueStorageType;
-
-        typedef HashTable<KeyStorageType, ValueStorageType, PairFirstExtractor<ValueStorageType>,
-            StorageHashFunctions, ValueStorageTraits, KeyStorageTraits> HashTableType;
-
-        typedef RefPtrHashMapRawKeyTranslator<RawKeyType, ValueType, ValueTraits, ValueStorageTraits, HashFunctions>
+        typedef HashTable<KeyType, ValueType, PairFirstExtractor<ValueType>,
+            HashFunctions, ValueTraits, KeyTraits> HashTableType;
+
+        typedef RefPtrHashMapRawKeyTranslator<RawKeyType, ValueType, ValueTraits, HashFunctions>
             RawKeyTranslator;
 
@@ -83 +68 @@
         typedef HashTableIteratorAdapter<HashTableType, ValueType> iterator;
         typedef HashTableConstIteratorAdapter<HashTableType, ValueType> const_iterator;
-
-        HashMap();
-        HashMap(const HashMap&);
-        HashMap& operator=(const HashMap&);
-        ~HashMap();
 
         void swap(HashMap&);
@@ -134 +114 @@
         pair<iterator, bool> inlineAdd(const KeyType&, const MappedType&);
         pair<iterator, bool> inlineAdd(RawKeyType, const MappedType&);
-        void refAll();
-        void derefAll();
 
         HashTableType m_impl;
@@ -141 +119 @@
     
     template<typename T, typename U, typename V, typename W, typename X>
-    inline void HashMap<RefPtr<T>, U, V, W, X>::refAll()
-    {
-        HashTableRefCounter<HashTableType, ValueTraits>::refAll(m_impl);
-    }
-
-    template<typename T, typename U, typename V, typename W, typename X>
-    inline void HashMap<RefPtr<T>, U, V, W, X>::derefAll()
-    {
-        HashTableRefCounter<HashTableType, ValueTraits>::derefAll(m_impl);
-    }
-
-    template<typename T, typename U, typename V, typename W, typename X>
-    inline HashMap<RefPtr<T>, U, V, W, X>::HashMap()
-    {
-    }
-
-    template<typename T, typename U, typename V, typename W, typename X>
-    inline HashMap<RefPtr<T>, U, V, W, X>::HashMap(const HashMap& other)
-        : m_impl(other.m_impl)
-    {
-        refAll();
-    }
-
-    template<typename T, typename U, typename V, typename W, typename X>
-    inline HashMap<RefPtr<T>, U, V, W, X>& HashMap<RefPtr<T>, U, V, W, X>::operator=(const HashMap& other)
-    {
-        HashMap tmp(other);
-        swap(tmp); 
-        return *this;
-    }
-
-    template<typename T, typename U, typename V, typename W, typename X>
     inline void HashMap<RefPtr<T>, U, V, W, X>::swap(HashMap& other)
     {
         m_impl.swap(other.m_impl); 
-    }
-
-    template<typename T, typename U, typename V, typename W, typename X>
-    inline HashMap<RefPtr<T>, U, V, W, X>::~HashMap()
-    {
-        derefAll();
     }
 
@@ -229 +169 @@
     inline typename HashMap<RefPtr<T>, U, V, W, X>::iterator HashMap<RefPtr<T>, U, V, W, X>::find(const KeyType& key)
     {
-        return m_impl.find(*(const KeyStorageType*)&key);
+        return m_impl.find(key);
     }
 
@@ -241 +181 @@
     inline typename HashMap<RefPtr<T>, U, V, W, X>::const_iterator HashMap<RefPtr<T>, U, V, W, X>::find(const KeyType& key) const
     {
-        return m_impl.find(*(const KeyStorageType*)&key);
+        return m_impl.find(key);
     }
 
@@ -253 +193 @@
     inline bool HashMap<RefPtr<T>, U, V, W, X>::contains(const KeyType& key) const
     {
-        return m_impl.contains(*(const KeyStorageType*)&key);
+        return m_impl.contains(key);
     }
 
@@ -266 +206 @@
     HashMap<RefPtr<T>, U, V, W, X>::inlineAdd(const KeyType& key, const MappedType& mapped) 
     {
-        const bool canReplaceDeletedKey = !KeyTraits::needsDestruction || KeyStorageTraits::needsDestruction;
-        typedef HashMapTranslator<canReplaceDeletedKey, ValueType, ValueTraits, ValueStorageTraits, HashFunctions> TranslatorType;
+        typedef HashMapTranslator<ValueType, ValueTraits, HashFunctions> TranslatorType;
         return m_impl.template add<KeyType, MappedType, TranslatorType>(key, mapped);
     }
@@ -320 +259 @@
     HashMap<RefPtr<T>, U, V, W, MappedTraits>::get(const KeyType& key) const
     {
-        ValueStorageType* entry = const_cast<HashTableType&>(m_impl).lookup(*(const KeyStorageType*)&key);
+        ValueType* entry = const_cast<HashTableType&>(m_impl).lookup(key);
         if (!entry)
             return MappedTraits::emptyValue();
-        return ((ValueType *)entry)->second;
+        return entry->second;
     }
 
@@ -349 +288 @@
             return;
         m_impl.checkTableConsistency();
-        RefCounter<ValueTraits, ValueStorageTraits>::deref(*it.m_impl);
         m_impl.removeWithoutEntryConsistencyCheck(it.m_impl);
     }
@@ -368 +306 @@
     inline void HashMap<RefPtr<T>, U, V, W, X>::clear()
     {
-        derefAll();
         m_impl.clear();
     }