Create HeapLinkedHashSet and LinkedHashSet, ordered heap-friendly hash sets.

Source/wtf/ListHashSet.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2011, Benjamin Poulain <ikipou@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 282 matching lines @@
 
     template<typename HashArg> struct ListHashSetNodeHashFunctions {
         template<typename T> static unsigned hash(const T& key) { return HashArg::hash(key->m_value); }
         template<typename T> static bool equal(const T& a, const T& b) { return HashArg::equal(a->m_value, b->m_value); }
         static const bool safeToCompareToEmptyOrDeleted = false;
     };
 
     template<typename ValueArg, size_t inlineCapacity, typename HashArg> class ListHashSetIterator {
     private:
         typedef ListHashSet<ValueArg, inlineCapacity, HashArg> ListHashSetType;
-        typedef ListHashSetIterator<ValueArg, inlineCapacity, HashArg> iterator;
         typedef ListHashSetConstIterator<ValueArg, inlineCapacity, HashArg> const_iterator;
         typedef ListHashSetNode<ValueArg, inlineCapacity> Node;
         typedef ValueArg ValueType;
         typedef ValueType& ReferenceType;
         typedef ValueType* PointerType;
 
         friend class ListHashSet<ValueArg, inlineCapacity, HashArg>;
 
         ListHashSetIterator(const ListHashSetType* set, Node* position) : m_iterator(set, position) { }
 
     public:
         ListHashSetIterator() { }
 
         // default copy, assignment and destructor are OK
 
         PointerType get() const { return const_cast<PointerType>(m_iterator.get()); }
         ReferenceType operator*() const { return *get(); }
         PointerType operator->() const { return get(); }
 
-        iterator& operator++() { ++m_iterator; return *this; }
+        ListHashSetIterator& operator++() { ++m_iterator; return *this; }
 
         // postfix ++ intentionally omitted
 
-        iterator& operator--() { --m_iterator; return *this; }
+        ListHashSetIterator& operator--() { --m_iterator; return *this; }
 
         // postfix -- intentionally omitted
 
         // Comparison.
-        bool operator==(const iterator& other) const { return m_iterator == other.m_iterator; }
-        bool operator!=(const iterator& other) const { return m_iterator != other.m_iterator; }
+        bool operator==(const ListHashSetIterator& other) const { return m_iterator == other.m_iterator; }
+        bool operator!=(const ListHashSetIterator& other) const { return m_iterator != other.m_iterator; }
 
         operator const_iterator() const { return m_iterator; }
 
     private:
         Node* node() { return m_iterator.node(); }
 
         const_iterator m_iterator;
     };
 
     template<typename ValueArg, size_t inlineCapacity, typename HashArg> class ListHashSetConstIterator {
     private:
         typedef ListHashSet<ValueArg, inlineCapacity, HashArg> ListHashSetType;
-        typedef ListHashSetIterator<ValueArg, inlineCapacity, HashArg> iterator;
         typedef ListHashSetConstIterator<ValueArg, inlineCapacity, HashArg> const_iterator;
         typedef ListHashSetNode<ValueArg, inlineCapacity> Node;
         typedef ValueArg ValueType;
         typedef const ValueType& ReferenceType;
         typedef const ValueType* PointerType;
 
         friend class ListHashSet<ValueArg, inlineCapacity, HashArg>;
         friend class ListHashSetIterator<ValueArg, inlineCapacity, HashArg>;
 
         ListHashSetConstIterator(const ListHashSetType* set, Node* position)
@@ skipping 582 matching lines @@
     inline ListHashSetIterator<T, inlineCapacity, U> ListHashSet<T, inlineCapacity, U>::makeIterator(Node* position)
     {
         return ListHashSetIterator<T, inlineCapacity, U>(this, position);
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     inline ListHashSetConstIterator<T, inlineCapacity, U> ListHashSet<T, inlineCapacity, U>::makeConstIterator(Node* position) const
     {
         return ListHashSetConstIterator<T, inlineCapacity, U>(this, position);
     }
+
     template<bool, typename ValueType, typename HashTableType>
     void deleteAllValues(HashTableType& collection)
     {
         typedef typename HashTableType::const_iterator iterator;
         iterator end = collection.end();
         for (iterator it = collection.begin(); it != end; ++it)
             delete (*it)->m_value;
     }
 
+    // Warning: After and while calling this you have a collection with deleted
+    // pointers. Consider using a smart pointer like OwnPtr and calling clear()
+    // instead.
     template<typename T, size_t inlineCapacity, typename U>
     inline void deleteAllValues(const ListHashSet<T, inlineCapacity, U>& collection)
     {
         deleteAllValues<true, typename ListHashSet<T, inlineCapacity, U>::ValueType>(collection.m_impl);
     }
 
 } // namespace WTF
 
 using WTF::ListHashSet;
 
 #endif /* WTF_ListHashSet_h */