[webkit-changes] [223236] trunk

Thu, 12 Oct 2017 05:46:18 -0700

Title: [223236] trunk
Revision
223236
Author
commit-qu...@webkit.org
Date
2017-10-12 05:45:57 -0700 (Thu, 12 Oct 2017)

Log Message

It should be possible to iterate just the values (and not the counts) of a HashCountedSet
https://bugs.webkit.org/show_bug.cgi?id=178169

Patch by Sam Weinig <s...@webkit.org> on 2017-10-12
Reviewed by Daniel Bates.

Source/WTF:

Cleanup (fix indentation, simplify type names, adopt using), and add a values() range to
HashCountedSet. This will allow getting a Vector of all the values (and not the counts)
using the new copyToVector.

* wtf/HashCountedSet.h:

Tools:

* TestWebKitAPI/Tests/WTF/HashCountedSet.cpp:
(TestWebKitAPI::TEST):
Add test for HashCountedSet's new values() range.

Modified Paths

Diff

Modified: trunk/Source/WTF/ChangeLog (223235 => 223236)


--- trunk/Source/WTF/ChangeLog	2017-10-12 11:58:43 UTC (rev 223235)
+++ trunk/Source/WTF/ChangeLog	2017-10-12 12:45:57 UTC (rev 223236)
@@ -1,3 +1,16 @@
+2017-10-12  Sam Weinig  <s...@webkit.org>
+
+        It should be possible to iterate just the values (and not the counts) of a HashCountedSet
+        https://bugs.webkit.org/show_bug.cgi?id=178169
+
+        Reviewed by Daniel Bates.
+
+        Cleanup (fix indentation, simplify type names, adopt using), and add a values() range to
+        HashCountedSet. This will allow getting a Vector of all the values (and not the counts)
+        using the new copyToVector. 
+
+        * wtf/HashCountedSet.h:
+
 2017-10-11  Michael Saboff  <msab...@apple.com>
 
         [JSC] Add ability to build with ARMV8 ILP32 ABI

Modified: trunk/Source/WTF/wtf/HashCountedSet.h (223235 => 223236)


--- trunk/Source/WTF/wtf/HashCountedSet.h	2017-10-12 11:58:43 UTC (rev 223235)
+++ trunk/Source/WTF/wtf/HashCountedSet.h	2017-10-12 12:45:57 UTC (rev 223236)
@@ -18,8 +18,7 @@
  *
  */
 
-#ifndef WTF_HashCountedSet_h
-#define WTF_HashCountedSet_h
+#pragma once
 
 #include <initializer_list>
 #include <wtf/Assertions.h>
@@ -28,298 +27,315 @@
 
 namespace WTF {
 
-    template<typename Value, typename HashFunctions = typename DefaultHash<Value>::Hash, typename Traits = HashTraits<Value>>
-    class HashCountedSet final {
-        WTF_MAKE_FAST_ALLOCATED;
-    private:
-        typedef HashMap<Value, unsigned, HashFunctions, Traits> ImplType;
-    public:
-        typedef Value ValueType;
-        typedef typename ImplType::iterator iterator;
-        typedef typename ImplType::const_iterator const_iterator;
-        typedef typename ImplType::AddResult AddResult;
+template<typename Value, typename HashFunctions = typename DefaultHash<Value>::Hash, typename Traits = HashTraits<Value>>
+class HashCountedSet final {
+    WTF_MAKE_FAST_ALLOCATED;
+private:
+    using ImplType = HashMap<Value, unsigned, HashFunctions, Traits>;
+public:
+    using ValueType = Value;
+    using iterator = typename ImplType::iterator;
+    using const_iterator = typename ImplType::const_iterator;
+    using ValuesIteratorRange = typename ImplType::KeysIteratorRange;
+    using ValuesConstIteratorRange = typename ImplType::KeysConstIteratorRange;
+    using AddResult = typename ImplType::AddResult;
 
-        HashCountedSet()
-        {
-        }
+    HashCountedSet()
+    {
+    }
 
-        HashCountedSet(std::initializer_list<typename ImplType::KeyValuePairType> initializerList)
-        {
-            for (const auto& keyValuePair : initializerList)
-                add(keyValuePair.key, keyValuePair.value);
-        }
+    HashCountedSet(std::initializer_list<typename ImplType::KeyValuePairType> initializerList)
+    {
+        for (const auto& keyValuePair : initializerList)
+            add(keyValuePair.key, keyValuePair.value);
+    }
 
-        HashCountedSet(std::initializer_list<typename ImplType::KeyType> initializerList)
-        {
-            for (const auto& value : initializerList)
-                add(value);
-        }
-        
-        void swap(HashCountedSet&);
-        
-        unsigned size() const;
-        unsigned capacity() const;
-        bool isEmpty() const;
-        
-        // Iterators iterate over pairs of values and counts.
-        iterator begin();
-        iterator end();
-        const_iterator begin() const;
-        const_iterator end() const;
-        
-        iterator find(const ValueType&);
-        const_iterator find(const ValueType&) const;
-        bool contains(const ValueType&) const;
-        unsigned count(const ValueType&) const;
+    HashCountedSet(std::initializer_list<typename ImplType::KeyType> initializerList)
+    {
+        for (const auto& value : initializerList)
+            add(value);
+    }
+    
+    void swap(HashCountedSet&);
+    
+    unsigned size() const;
+    unsigned capacity() const;
+    bool isEmpty() const;
+    
+    // Iterators iterate over pairs of values and counts.
+    iterator begin();
+    iterator end();
+    const_iterator begin() const;
+    const_iterator end() const;
 
-        // Increments the count if an equal value is already present.
-        // The return value includes both an iterator to the value's location,
-        // and an isNewEntry bool that indicates whether it is a new or existing entry.
-        AddResult add(const ValueType&);
-        AddResult add(ValueType&&);
+    ValuesIteratorRange values();
+    const ValuesConstIteratorRange values() const;
 
-        // Increments the count of a value by the passed amount.
-        AddResult add(const ValueType&, unsigned);
-        AddResult add(ValueType&&, unsigned);
+    iterator find(const ValueType&);
+    const_iterator find(const ValueType&) const;
+    bool contains(const ValueType&) const;
+    unsigned count(const ValueType&) const;
 
-        // Decrements the count of the value, and removes it if count goes down to zero.
-        // Returns true if the value is removed.
-        bool remove(const ValueType&);
-        bool remove(iterator);
- 
-        // Removes the value, regardless of its count.
-        // Returns true if a value was removed.
-        bool removeAll(iterator);
-        bool removeAll(const ValueType&);
+    // Increments the count if an equal value is already present.
+    // The return value includes both an iterator to the value's location,
+    // and an isNewEntry bool that indicates whether it is a new or existing entry.
+    AddResult add(const ValueType&);
+    AddResult add(ValueType&&);
 
-        // Clears the whole set.
-        void clear();
+    // Increments the count of a value by the passed amount.
+    AddResult add(const ValueType&, unsigned);
+    AddResult add(ValueType&&, unsigned);
 
-        // Overloads for smart pointer keys that take the raw pointer type as the parameter.
-        template<typename V = ValueType> typename std::enable_if<IsSmartPtr<V>::value, iterator>::type find(typename GetPtrHelper<V>::PtrType);
-        template<typename V = ValueType> typename std::enable_if<IsSmartPtr<V>::value, const_iterator>::type find(typename GetPtrHelper<V>::PtrType) const;
-        template<typename V = ValueType> typename std::enable_if<IsSmartPtr<V>::value, bool>::type contains(typename GetPtrHelper<V>::PtrType) const;
-        template<typename V = ValueType> typename std::enable_if<IsSmartPtr<V>::value, unsigned>::type count(typename GetPtrHelper<V>::PtrType) const;
-        template<typename V = ValueType> typename std::enable_if<IsSmartPtr<V>::value, bool>::type remove(typename GetPtrHelper<V>::PtrType);
+    // Decrements the count of the value, and removes it if count goes down to zero.
+    // Returns true if the value is removed.
+    bool remove(const ValueType&);
+    bool remove(iterator);
 
-    private:
-        ImplType m_impl;
-    };
+    // Removes the value, regardless of its count.
+    // Returns true if a value was removed.
+    bool removeAll(iterator);
+    bool removeAll(const ValueType&);
 
+    // Clears the whole set.
+    void clear();
 
-    template<typename Value, typename HashFunctions, typename Traits>
-    inline void HashCountedSet<Value, HashFunctions, Traits>::swap(HashCountedSet& other)
-    {
-        m_impl.swap(other.m_impl);
-    }
-    
-    template<typename Value, typename HashFunctions, typename Traits>
-    inline unsigned HashCountedSet<Value, HashFunctions, Traits>::size() const
-    {
-        return m_impl.size(); 
-    }
-    
-    template<typename Value, typename HashFunctions, typename Traits>
-    inline unsigned HashCountedSet<Value, HashFunctions, Traits>::capacity() const
-    {
-        return m_impl.capacity(); 
-    }
-    
-    template<typename Value, typename HashFunctions, typename Traits>
-    inline bool HashCountedSet<Value, HashFunctions, Traits>::isEmpty() const
-    {
-        return size() == 0; 
-    }
-    
-    template<typename Value, typename HashFunctions, typename Traits>
-    inline typename HashCountedSet<Value, HashFunctions, Traits>::iterator HashCountedSet<Value, HashFunctions, Traits>::begin()
-    {
-        return m_impl.begin(); 
-    }
+    // Overloads for smart pointer keys that take the raw pointer type as the parameter.
+    template<typename V = ValueType> typename std::enable_if<IsSmartPtr<V>::value, iterator>::type find(typename GetPtrHelper<V>::PtrType);
+    template<typename V = ValueType> typename std::enable_if<IsSmartPtr<V>::value, const_iterator>::type find(typename GetPtrHelper<V>::PtrType) const;
+    template<typename V = ValueType> typename std::enable_if<IsSmartPtr<V>::value, bool>::type contains(typename GetPtrHelper<V>::PtrType) const;
+    template<typename V = ValueType> typename std::enable_if<IsSmartPtr<V>::value, unsigned>::type count(typename GetPtrHelper<V>::PtrType) const;
+    template<typename V = ValueType> typename std::enable_if<IsSmartPtr<V>::value, bool>::type remove(typename GetPtrHelper<V>::PtrType);
 
-    template<typename Value, typename HashFunctions, typename Traits>
-    inline typename HashCountedSet<Value, HashFunctions, Traits>::iterator HashCountedSet<Value, HashFunctions, Traits>::end()
-    {
-        return m_impl.end(); 
-    }
-    
-    template<typename Value, typename HashFunctions, typename Traits>
-    inline typename HashCountedSet<Value, HashFunctions, Traits>::const_iterator HashCountedSet<Value, HashFunctions, Traits>::begin() const
-    {
-        return m_impl.begin(); 
-    }
-    
-    template<typename Value, typename HashFunctions, typename Traits>
-    inline typename HashCountedSet<Value, HashFunctions, Traits>::const_iterator HashCountedSet<Value, HashFunctions, Traits>::end() const
-    {
-        return m_impl.end(); 
-    }
-    
-    template<typename Value, typename HashFunctions, typename Traits>
-    inline typename HashCountedSet<Value, HashFunctions, Traits>::iterator HashCountedSet<Value, HashFunctions, Traits>::find(const ValueType& value)
-    {
-        return m_impl.find(value); 
-    }
-    
-    template<typename Value, typename HashFunctions, typename Traits>
-    inline typename HashCountedSet<Value, HashFunctions, Traits>::const_iterator HashCountedSet<Value, HashFunctions, Traits>::find(const ValueType& value) const
-    {
-        return m_impl.find(value); 
-    }
-    
-    template<typename Value, typename HashFunctions, typename Traits>
-    inline bool HashCountedSet<Value, HashFunctions, Traits>::contains(const ValueType& value) const
-    {
-        return m_impl.contains(value); 
-    }
+private:
+    ImplType m_impl;
+};
 
-    template<typename Value, typename HashFunctions, typename Traits>
-    inline unsigned HashCountedSet<Value, HashFunctions, Traits>::count(const ValueType& value) const
-    {
-        return m_impl.get(value);
-    }
-    
-    template<typename Value, typename HashFunctions, typename Traits>
-    inline typename HashCountedSet<Value, HashFunctions, Traits>::AddResult HashCountedSet<Value, HashFunctions, Traits>::add(const ValueType &value)
-    {
-        AddResult result = m_impl.add(value, 0);
-        ++result.iterator->value;
-        return result;
-    }
 
-    template<typename Value, typename HashFunctions, typename Traits>
-    inline typename HashCountedSet<Value, HashFunctions, Traits>::AddResult HashCountedSet<Value, HashFunctions, Traits>::add(ValueType&& value)
-    {
-        AddResult result = m_impl.add(std::forward<Value>(value), 0);
-        ++result.iterator->value;
-        return result;
-    }
+template<typename Value, typename HashFunctions, typename Traits>
+inline void HashCountedSet<Value, HashFunctions, Traits>::swap(HashCountedSet& other)
+{
+    m_impl.swap(other.m_impl);
+}
 
-    template<typename Value, typename HashFunctions, typename Traits>
-    inline typename HashCountedSet<Value, HashFunctions, Traits>::AddResult HashCountedSet<Value, HashFunctions, Traits>::add(const ValueType& value, unsigned count)
-    {
-        AddResult result = m_impl.add(value, 0);
-        result.iterator->value += count;
-        return result;
-    }
-    
-    template<typename Value, typename HashFunctions, typename Traits>
-    inline typename HashCountedSet<Value, HashFunctions, Traits>::AddResult HashCountedSet<Value, HashFunctions, Traits>::add(ValueType&& value, unsigned count)
-    {
-        AddResult result = m_impl.add(std::forward<Value>(value), 0);
-        result.iterator->value += count;
-        return result;
-    }
-    
-    template<typename Value, typename HashFunctions, typename Traits>
-    inline bool HashCountedSet<Value, HashFunctions, Traits>::remove(const ValueType& value)
-    {
-        return remove(find(value));
-    }
-    
-    template<typename Value, typename HashFunctions, typename Traits>
-    inline bool HashCountedSet<Value, HashFunctions, Traits>::remove(iterator it)
-    {
-        if (it == end())
-            return false;
+template<typename Value, typename HashFunctions, typename Traits>
+inline unsigned HashCountedSet<Value, HashFunctions, Traits>::size() const
+{
+    return m_impl.size();
+}
 
-        unsigned oldVal = it->value;
-        ASSERT(oldVal);
-        unsigned newVal = oldVal - 1;
-        if (newVal) {
-            it->value = newVal;
-            return false;
-        }
+template<typename Value, typename HashFunctions, typename Traits>
+inline unsigned HashCountedSet<Value, HashFunctions, Traits>::capacity() const
+{
+    return m_impl.capacity();
+}
 
-        m_impl.remove(it);
-        return true;
-    }
-    
-    template<typename Value, typename HashFunctions, typename Traits>
-    inline bool HashCountedSet<Value, HashFunctions, Traits>::removeAll(const ValueType& value)
-    {
-        return removeAll(find(value));
-    }
-    
-    template<typename Value, typename HashFunctions, typename Traits>
-    inline bool HashCountedSet<Value, HashFunctions, Traits>::removeAll(iterator it)
-    {
-        if (it == end())
-            return false;
+template<typename Value, typename HashFunctions, typename Traits>
+inline bool HashCountedSet<Value, HashFunctions, Traits>::isEmpty() const
+{
+    return size() == 0;
+}
 
-        m_impl.remove(it);
-        return true;
-    }
-    
-    template<typename Value, typename HashFunctions, typename Traits>
-    inline void HashCountedSet<Value, HashFunctions, Traits>::clear()
-    {
-        m_impl.clear(); 
-    }
-    
-    template<typename Value, typename HashFunctions, typename Traits, typename VectorType>
-    inline void copyToVector(const HashCountedSet<Value, HashFunctions, Traits>& collection, VectorType& vector)
-    {
-        typedef typename HashCountedSet<Value, HashFunctions, Traits>::const_iterator iterator;
-        
-        vector.resize(collection.size());
-        
-        iterator it = collection.begin();
-        iterator end = collection.end();
-        for (unsigned i = 0; it != end; ++it, ++i)
-            vector[i] = *it;
-    }
+template<typename Value, typename HashFunctions, typename Traits>
+inline auto HashCountedSet<Value, HashFunctions, Traits>::begin() -> iterator
+{
+    return m_impl.begin();
+}
 
-    template<typename Value, typename HashFunctions, typename Traits>
-    inline void copyToVector(const HashCountedSet<Value, HashFunctions, Traits>& collection, Vector<Value>& vector)
-    {
-        typedef typename HashCountedSet<Value, HashFunctions, Traits>::const_iterator iterator;
-        
-        vector.resize(collection.size());
-        
-        iterator it = collection.begin();
-        iterator end = collection.end();
-        for (unsigned i = 0; it != end; ++it, ++i)
-            vector[i] = (*it).key;
-    }
+template<typename Value, typename HashFunctions, typename Traits>
+inline auto HashCountedSet<Value, HashFunctions, Traits>::end() -> iterator
+{
+    return m_impl.end();
+}
 
-    template<typename Value, typename HashFunctions, typename Traits>
-    template<typename V>
-    inline auto HashCountedSet<Value, HashFunctions, Traits>::find(typename GetPtrHelper<V>::PtrType value) -> typename std::enable_if<IsSmartPtr<V>::value, iterator>::type
-    {
-        return m_impl.find(value);
+template<typename Value, typename HashFunctions, typename Traits>
+inline auto HashCountedSet<Value, HashFunctions, Traits>::begin() const -> const_iterator
+{
+    return m_impl.begin();
+}
+
+template<typename Value, typename HashFunctions, typename Traits>
+inline auto HashCountedSet<Value, HashFunctions, Traits>::end() const -> const_iterator
+{
+    return m_impl.end();
+}
+
+template<typename Value, typename HashFunctions, typename Traits>
+inline auto HashCountedSet<Value, HashFunctions, Traits>::values() -> ValuesIteratorRange
+{
+    return m_impl.keys();
+}
+
+template<typename Value, typename HashFunctions, typename Traits>
+inline auto HashCountedSet<Value, HashFunctions, Traits>::values() const -> const ValuesConstIteratorRange
+{
+    return m_impl.keys();
+}
+
+template<typename Value, typename HashFunctions, typename Traits>
+inline auto HashCountedSet<Value, HashFunctions, Traits>::find(const ValueType& value) -> iterator
+{
+    return m_impl.find(value);
+}
+
+template<typename Value, typename HashFunctions, typename Traits>
+inline auto HashCountedSet<Value, HashFunctions, Traits>::find(const ValueType& value) const -> const_iterator
+{
+    return m_impl.find(value);
+}
+
+template<typename Value, typename HashFunctions, typename Traits>
+inline bool HashCountedSet<Value, HashFunctions, Traits>::contains(const ValueType& value) const
+{
+    return m_impl.contains(value);
+}
+
+template<typename Value, typename HashFunctions, typename Traits>
+inline unsigned HashCountedSet<Value, HashFunctions, Traits>::count(const ValueType& value) const
+{
+    return m_impl.get(value);
+}
+
+template<typename Value, typename HashFunctions, typename Traits>
+inline auto HashCountedSet<Value, HashFunctions, Traits>::add(const ValueType &value) -> AddResult
+{
+    auto result = m_impl.add(value, 0);
+    ++result.iterator->value;
+    return result;
+}
+
+template<typename Value, typename HashFunctions, typename Traits>
+inline auto HashCountedSet<Value, HashFunctions, Traits>::add(ValueType&& value) -> AddResult
+{
+    auto result = m_impl.add(std::forward<Value>(value), 0);
+    ++result.iterator->value;
+    return result;
+}
+
+template<typename Value, typename HashFunctions, typename Traits>
+inline auto HashCountedSet<Value, HashFunctions, Traits>::add(const ValueType& value, unsigned count) -> AddResult
+{
+    auto result = m_impl.add(value, 0);
+    result.iterator->value += count;
+    return result;
+}
+
+template<typename Value, typename HashFunctions, typename Traits>
+inline auto HashCountedSet<Value, HashFunctions, Traits>::add(ValueType&& value, unsigned count) -> AddResult
+{
+    auto result = m_impl.add(std::forward<Value>(value), 0);
+    result.iterator->value += count;
+    return result;
+}
+
+template<typename Value, typename HashFunctions, typename Traits>
+inline bool HashCountedSet<Value, HashFunctions, Traits>::remove(const ValueType& value)
+{
+    return remove(find(value));
+}
+
+template<typename Value, typename HashFunctions, typename Traits>
+inline bool HashCountedSet<Value, HashFunctions, Traits>::remove(iterator it)
+{
+    if (it == end())
+        return false;
+
+    unsigned oldVal = it->value;
+    ASSERT(oldVal);
+    unsigned newVal = oldVal - 1;
+    if (newVal) {
+        it->value = newVal;
+        return false;
     }
-    
-    template<typename Value, typename HashFunctions, typename Traits>
-    template<typename V>
-    inline auto HashCountedSet<Value, HashFunctions, Traits>::find(typename GetPtrHelper<V>::PtrType value) const -> typename std::enable_if<IsSmartPtr<V>::value, const_iterator>::type
-    {
-        return m_impl.find(value);
-    }
-    
-    template<typename Value, typename HashFunctions, typename Traits>
-    template<typename V>
-    inline auto HashCountedSet<Value, HashFunctions, Traits>::contains(typename GetPtrHelper<V>::PtrType value) const -> typename std::enable_if<IsSmartPtr<V>::value, bool>::type
-    {
-        return m_impl.contains(value);
-    }
-    
-    template<typename Value, typename HashFunctions, typename Traits>
-    template<typename V>
-    inline auto HashCountedSet<Value, HashFunctions, Traits>::count(typename GetPtrHelper<V>::PtrType value) const -> typename std::enable_if<IsSmartPtr<V>::value, unsigned>::type
-    {
-        return m_impl.get(value);
-    }
-    
-    template<typename Value, typename HashFunctions, typename Traits>
-    template<typename V>
-    inline auto HashCountedSet<Value, HashFunctions, Traits>::remove(typename GetPtrHelper<V>::PtrType value) -> typename std::enable_if<IsSmartPtr<V>::value, bool>::type
-    {
-        return remove(find(value));
-    }
 
+    m_impl.remove(it);
+    return true;
+}
+
+template<typename Value, typename HashFunctions, typename Traits>
+inline bool HashCountedSet<Value, HashFunctions, Traits>::removeAll(const ValueType& value)
+{
+    return removeAll(find(value));
+}
+
+template<typename Value, typename HashFunctions, typename Traits>
+inline bool HashCountedSet<Value, HashFunctions, Traits>::removeAll(iterator it)
+{
+    if (it == end())
+        return false;
+
+    m_impl.remove(it);
+    return true;
+}
+
+template<typename Value, typename HashFunctions, typename Traits>
+inline void HashCountedSet<Value, HashFunctions, Traits>::clear()
+{
+    m_impl.clear();
+}
+
+template<typename Value, typename HashFunctions, typename Traits>
+template<typename V>
+inline auto HashCountedSet<Value, HashFunctions, Traits>::find(typename GetPtrHelper<V>::PtrType value) -> typename std::enable_if<IsSmartPtr<V>::value, iterator>::type
+{
+    return m_impl.find(value);
+}
+
+template<typename Value, typename HashFunctions, typename Traits>
+template<typename V>
+inline auto HashCountedSet<Value, HashFunctions, Traits>::find(typename GetPtrHelper<V>::PtrType value) const -> typename std::enable_if<IsSmartPtr<V>::value, const_iterator>::type
+{
+    return m_impl.find(value);
+}
+
+template<typename Value, typename HashFunctions, typename Traits>
+template<typename V>
+inline auto HashCountedSet<Value, HashFunctions, Traits>::contains(typename GetPtrHelper<V>::PtrType value) const -> typename std::enable_if<IsSmartPtr<V>::value, bool>::type
+{
+    return m_impl.contains(value);
+}
+
+template<typename Value, typename HashFunctions, typename Traits>
+template<typename V>
+inline auto HashCountedSet<Value, HashFunctions, Traits>::count(typename GetPtrHelper<V>::PtrType value) const -> typename std::enable_if<IsSmartPtr<V>::value, unsigned>::type
+{
+    return m_impl.get(value);
+}
+
+template<typename Value, typename HashFunctions, typename Traits>
+template<typename V>
+inline auto HashCountedSet<Value, HashFunctions, Traits>::remove(typename GetPtrHelper<V>::PtrType value) -> typename std::enable_if<IsSmartPtr<V>::value, bool>::type
+{
+    return remove(find(value));
+}
+
+template<typename Value, typename HashFunctions, typename Traits, typename VectorType>
+inline void copyToVector(const HashCountedSet<Value, HashFunctions, Traits>& collection, VectorType& vector)
+{
+    typedef typename HashCountedSet<Value, HashFunctions, Traits>::const_iterator iterator;
+
+    vector.resize(collection.size());
+
+    iterator it = collection.begin();
+    iterator end = collection.end();
+    for (unsigned i = 0; it != end; ++it, ++i)
+        vector[i] = *it;
+}
+
+template<typename Value, typename HashFunctions, typename Traits>
+inline void copyToVector(const HashCountedSet<Value, HashFunctions, Traits>& collection, Vector<Value>& vector)
+{
+    typedef typename HashCountedSet<Value, HashFunctions, Traits>::const_iterator iterator;
+
+    vector.resize(collection.size());
+
+    iterator it = collection.begin();
+    iterator end = collection.end();
+    for (unsigned i = 0; it != end; ++it, ++i)
+        vector[i] = (*it).key;
+}
+
 } // namespace WTF
 
 using WTF::HashCountedSet;
 
-#endif /* WTF_HashCountedSet_h */
+

Modified: trunk/Tools/ChangeLog (223235 => 223236)


--- trunk/Tools/ChangeLog	2017-10-12 11:58:43 UTC (rev 223235)
+++ trunk/Tools/ChangeLog	2017-10-12 12:45:57 UTC (rev 223236)
@@ -1,3 +1,14 @@
+2017-10-12  Sam Weinig  <s...@webkit.org>
+
+        It should be possible to iterate just the values (and not the counts) of a HashCountedSet
+        https://bugs.webkit.org/show_bug.cgi?id=178169
+
+        Reviewed by Daniel Bates.
+
+        * TestWebKitAPI/Tests/WTF/HashCountedSet.cpp:
+        (TestWebKitAPI::TEST):
+        Add test for HashCountedSet's new values() range.
+
 2017-10-11  Frederic Wang  <fw...@igalia.com>
 
         run-safari --ios-simulator is no longer working with Xcode 9

Modified: trunk/Tools/TestWebKitAPI/Tests/WTF/HashCountedSet.cpp (223235 => 223236)


--- trunk/Tools/TestWebKitAPI/Tests/WTF/HashCountedSet.cpp	2017-10-12 11:58:43 UTC (rev 223235)
+++ trunk/Tools/TestWebKitAPI/Tests/WTF/HashCountedSet.cpp	2017-10-12 12:45:57 UTC (rev 223236)
@@ -469,4 +469,17 @@
     EXPECT_STREQ("ref(a) deref(a) ", takeLogStr().c_str());
 }
 
+TEST(WTF_HashCountedSet, Values)
+{
+    HashCountedSet<int> set { 1, 1, 2, 3, 3 };
+    
+    auto vector = copyToVector(set.values());
+    EXPECT_EQ(3U, vector.size());
+
+    std::sort(vector.begin(), vector.end());
+    EXPECT_EQ(1, vector[0]);
+    EXPECT_EQ(2, vector[1]);
+    EXPECT_EQ(3, vector[2]);
+}
+
 } // namespace TestWebKitAPI

_______________________________________________
webkit-changes mailing list
webkit-changes@lists.webkit.org
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to