Changeset 222170 in webkit

Timestamp:

Sep 18, 2017 11:52:10 AM (7 years ago)

Author:

commit-queue@webkit.org

Message:

Allow WTF::map to use any class that is iterable and has a size getter
​https://bugs.webkit.org/show_bug.cgi?id=177026

Patch by Youenn Fablet <​youenn@apple.com> on 2017-09-18
Reviewed by Darin Adler.

Source/WebCore:

No change of behavior.
Using WTF::map to go from maps to vectors.

• loader/appcache/ApplicationCacheHost.cpp:

(WebCore::ApplicationCacheHost::resourceList):

• page/DOMWindow.cpp:

(WebCore::DOMWindow::dispatchAllPendingUnloadEvents):

Source/WTF:

Computing the Item type given to the lambda using the iterator instead of ValueType which is specific to Vector.
Adding the possibility to pass a non const container reference and a lambda taking non const references as well.

• wtf/Vector.h:

(WTF::MapFunctionInspector::acceptsReference):
(WTF::Mapper::map):
(WTF::map):

Tools:

• TestWebKitAPI/Tests/WTF/Vector.cpp:

(TestWebKitAPI::TEST):

Location:

trunk

Files:

• Source/WTF/ChangeLog (modified) (1 diff)
• Source/WTF/wtf/Vector.h (modified) (1 diff)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/loader/appcache/ApplicationCacheHost.cpp (modified) (2 diffs)
• Source/WebCore/page/DOMWindow.cpp (modified) (1 diff)
• Tools/ChangeLog (modified) (1 diff)
• Tools/TestWebKitAPI/Tests/WTF/Vector.cpp (modified) (2 diffs)

trunk/Source/WTF/ChangeLog

@@ +1 @@
+2017-09-18  Youenn Fablet  <youenn@apple.com>
+
+        Allow WTF::map to use any class that is iterable and has a size getter
+        https://bugs.webkit.org/show_bug.cgi?id=177026
+
+        Reviewed by Darin Adler.
+
+        Computing the Item type given to the lambda using the iterator instead of ValueType which is specific to Vector.
+        Adding the possibility to pass a non const container reference and a lambda taking non const references as well. 
+
+        * wtf/Vector.h:
+        (WTF::MapFunctionInspector::acceptsReference):
+        (WTF::Mapper::map):
+        (WTF::map):
+
 2017-09-15  JF Bastien  <jfbastien@apple.com>
 

trunk/Source/WTF/wtf/Vector.h

@@ -1563 +1563 @@
 }
 
-template<typename Transformer, typename SourceType> struct Mapper {
+template<typename MapFunction, typename SourceType>
+struct MapFunctionInspector {
     using RealSourceType = typename std::remove_reference<SourceType>::type;
-    using SourceItemType = typename RealSourceType::ValueType;
-    using DestinationItemType = typename std::result_of<Transformer(SourceItemType&&)>::type;
-
-    static Vector<DestinationItemType> map(const RealSourceType& source, const Transformer& transformer)
+    using IteratorType = decltype(std::begin(std::declval<RealSourceType>()));
+    using SourceItemType = typename std::iterator_traits<IteratorType>::value_type;
+};
+
+template<typename MapFunction, typename SourceType, typename Enable = void>
+struct Mapper {
+    using SourceItemType = typename MapFunctionInspector<MapFunction, SourceType>::SourceItemType;
+    using DestinationItemType = typename std::result_of<MapFunction(SourceItemType&)>::type;
+
+    static Vector<DestinationItemType> map(SourceType source, const MapFunction& mapFunction)
     {
         Vector<DestinationItemType> result;
+        // FIXME: Use std::size when available on all compilers.
         result.reserveInitialCapacity(source.size());
         for (auto& item : source)
-            result.uncheckedAppend(transformer(item));
+            result.uncheckedAppend(mapFunction(item));
         return result;
     }
-
-    static Vector<DestinationItemType> map(RealSourceType&& source, const Transformer& transformer)
+};
+
+template<typename MapFunction, typename SourceType>
+struct Mapper<MapFunction, SourceType, typename std::enable_if<std::is_rvalue_reference<SourceType&&>::value>::type> {
+    using SourceItemType = typename MapFunctionInspector<MapFunction, SourceType>::SourceItemType;
+    using DestinationItemType = typename std::result_of<MapFunction(SourceItemType&&)>::type;
+
+    static Vector<DestinationItemType> map(SourceType source, const MapFunction& mapFunction)
     {
         Vector<DestinationItemType> result;
+        // FIXME: Use std::size when available on all compilers.
         result.reserveInitialCapacity(source.size());
         for (auto& item : source)
-            result.uncheckedAppend(transformer(std::forward<SourceItemType>(item)));
+            result.uncheckedAppend(mapFunction(WTFMove(item)));
         return result;
     }
 };
 
-template<typename Transformer, typename VectorType>
-Vector<typename Mapper<Transformer, VectorType>::DestinationItemType> map(VectorType&& source, Transformer&& transformer)
-{
-    return Mapper<Transformer, VectorType>::map(std::forward<VectorType>(source), std::forward<Transformer>(transformer));
+template<typename MapFunction, typename SourceType>
+Vector<typename Mapper<MapFunction, SourceType>::DestinationItemType> map(SourceType&& source, MapFunction&& mapFunction)
+{
+    return Mapper<MapFunction, SourceType>::map(std::forward<SourceType>(source), std::forward<MapFunction>(mapFunction));
 }
 

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2017-09-18  Youenn Fablet  <youenn@apple.com>
+
+        Allow WTF::map to use any class that is iterable and has a size getter
+        https://bugs.webkit.org/show_bug.cgi?id=177026
+
+        Reviewed by Darin Adler.
+
+        No change of behavior.
+        Using WTF::map to go from maps to vectors.
+
+        * loader/appcache/ApplicationCacheHost.cpp:
+        (WebCore::ApplicationCacheHost::resourceList):
+        * page/DOMWindow.cpp:
+        (WebCore::DOMWindow::dispatchAllPendingUnloadEvents):
+
 2017-09-18  Emilio Cobos Álvarez  <emilio@crisal.io>
 

trunk/Source/WebCore/loader/appcache/ApplicationCacheHost.cpp

@@ -328 +328 @@
 Vector<ApplicationCacheHost::ResourceInfo> ApplicationCacheHost::resourceList()
 {
-    Vector<ResourceInfo> result;
-
     auto* cache = applicationCache();
     if (!cache || !cache->isComplete())
-        return result;
-
-    result.reserveInitialCapacity(cache->resources().size());
-
-    for (auto& urlAndResource : cache->resources()) {
+        return { };
+
+    return WTF::map(cache->resources(), [] (auto& urlAndResource) -> ApplicationCacheHost::ResourceInfo {
         ASSERT(urlAndResource.value);
         auto& resource = *urlAndResource.value;
@@ -347 +343 @@
         bool isFallback = type & ApplicationCacheResource::Fallback;
 
-        result.uncheckedAppend({ resource.url(), isMaster, isManifest, isFallback, isForeign, isExplicit, resource.estimatedSizeInStorage() });
-    }
-
-    return result;
+        return { resource.url(), isMaster, isManifest, isFallback, isForeign, isExplicit, resource.estimatedSizeInStorage() };
+    });
 }
 

trunk/Source/WebCore/page/DOMWindow.cpp

@@ -298 +298 @@
         return;
 
-    Vector<Ref<DOMWindow>> windows;
-    windows.reserveInitialCapacity(set.size());
-    for (auto& keyValue : set)
-        windows.uncheckedAppend(*keyValue.key);
+    auto windows = WTF::map(set, [] (auto& keyValue) {
+        return Ref<DOMWindow>(*(keyValue.key));
+    });
 
     for (auto& window : windows) {

trunk/Tools/ChangeLog

@@ +1 @@
+2017-09-18  Youenn Fablet  <youenn@apple.com>
+
+        Allow WTF::map to use any class that is iterable and has a size getter
+        https://bugs.webkit.org/show_bug.cgi?id=177026
+
+        Reviewed by Darin Adler.
+
+        * TestWebKitAPI/Tests/WTF/Vector.cpp:
+        (TestWebKitAPI::TEST):
+
 2017-09-16  Filip Pizlo  <fpizlo@apple.com>
 

trunk/Tools/TestWebKitAPI/Tests/WTF/Vector.cpp

@@ -27 +27 @@
 
 #include "MoveOnly.h"
+#include <wtf/HashMap.h>
 #include <wtf/Vector.h>
-#include <wtf/text/CString.h>
+#include <wtf/text/StringHash.h>
+#include <wtf/text/WTFString.h>
 
 namespace TestWebKitAPI {
@@ -727 +729 @@
 }
 
+TEST(WTF_Vector, MapFromHashMap)
+{
+    HashMap<String, String> map;
+    map.set(String { "k1" }, String { "v1" });
+    map.set(String { "k2" }, String { "v2" });
+    map.set(String { "k3" }, String { "v3" });
+
+    auto mapped = WTF::map(map, [&] (KeyValuePair<String, String>& pair) -> String {
+        return pair.value;
+    });
+    std::sort(mapped.begin(), mapped.end(), WTF::codePointCompareLessThan);
+
+    EXPECT_EQ(3U, mapped.size());
+    EXPECT_TRUE(mapped[0] == "v1");
+    EXPECT_TRUE(mapped[1] == "v2");
+    EXPECT_TRUE(mapped[2] == "v3");
+
+    mapped = WTF::map(map, [&] (const auto& pair) -> String {
+        return pair.key;
+    });
+    std::sort(mapped.begin(), mapped.end(), WTF::codePointCompareLessThan);
+
+    EXPECT_EQ(3U, mapped.size());
+    EXPECT_TRUE(mapped[0] == "k1");
+    EXPECT_TRUE(mapped[1] == "k2");
+    EXPECT_TRUE(mapped[2] == "k3");
+
+    mapped = WTF::map(WTFMove(map), [&] (KeyValuePair<String, String>&& pair) -> String {
+        return WTFMove(pair.value);
+    });
+    std::sort(mapped.begin(), mapped.end(), WTF::codePointCompareLessThan);
+
+    EXPECT_EQ(3U, mapped.size());
+    EXPECT_TRUE(mapped[0] == "v1");
+    EXPECT_TRUE(mapped[1] == "v2");
+    EXPECT_TRUE(mapped[2] == "v3");
+
+    EXPECT_TRUE(map.contains("k1"));
+    EXPECT_TRUE(map.contains("k2"));
+    EXPECT_TRUE(map.contains("k3"));
+
+    EXPECT_TRUE(map.get("k1").isNull());
+    EXPECT_TRUE(map.get("k2").isNull());
+    EXPECT_TRUE(map.get("k3").isNull());
+
+}
+
 } // namespace TestWebKitAPI