common: add PathMap constructor to skip O(n*log(n)) work

Summary:
Add a constructor that directly takes `vector<pair<..>>>`, only sorting the vector if necessary. This is effectively a "bulk import" for tree entries.

Existing code constructs the PathMap by calling `PathMap::emplace()` in a loop, but that is inefficient since emplace does a `O(log(n))` lookup every time (even if the data is already sorted), and then potentially has to shift data around in the vector (if the data is not already sorted).

I'm going to use this in upcoming diffs to optimize tree construction.

Differential Revision: D81650017

fbshipit-source-id: 87a9ff11bbe60111bd165080414d63f479e958bb

Author: muirdm

eden/common/utils/PathMap.h

@@ -75,6 +75,14 @@ class PathMap : private folly::fbvector<std::pair<Key, Value>> {
       return isPathPieceLess(Piece(lhs.first), Piece(b), caseSensitive_);
     }
 
+    // Compare two stored Pairs.
+    template <typename A, typename B>
+    typename std::enable_if<std::is_convertible<A, Piece>::value, bool>::type
+    operator()(const std::pair<A, B>& lhs, const std::pair<A, B>& rhs) const {
+      return isPathPieceLess(
+          Piece(lhs.first), Piece(rhs.first), caseSensitive_);
+    }
+
     CaseSensitivity caseSensitive_{kPathMapDefaultCaseSensitive};
   };
 
@@ -123,6 +131,28 @@ class PathMap : private folly::fbvector<std::pair<Key, Value>> {
     }
   }
 
+  // Initialize using given vector of entries, sorting if needed.
+  // This is more efficient than calling PathMap::emplace n times.
+  PathMap(Vector&& entries, CaseSensitivity caseSensitive)
+      : Vector(std::move(entries)), compare_(caseSensitive) {
+    Vector& vec = *this;
+
+    // It seems like std::sort isn't guaranteed to be fast when the data is
+    // already sorted, so let's check ourselves.
+
+    bool needsSort = false;
+    for (size_t idx = 0; idx < vec.size(); idx++) {
+      if (idx > 0 && !compare_(vec[idx - 1].first, vec[idx].first)) {
+        needsSort = true;
+        break;
+      }
+    }
+
+    if (needsSort) {
+      std::sort(vec.begin(), vec.end(), compare_);
+    }
+  }
+
   // Inherit the underlying vector copy/assignment.
   PathMap(const PathMap& other) : Vector(other), compare_(other.compare_) {}
   PathMap& operator=(const PathMap& other) {

eden/common/utils/test/PathMapTest.cpp

@@ -340,3 +340,16 @@ TEST(PathMapTest, collatePathMaps_caseSensitive) {
   ASSERT_EQ(expected, collatePathMaps(a, b));
   ASSERT_EQ(expected.getCaseSensitivity(), CaseSensitivity::Sensitive);
 }
+
+TEST(PathMapTest, vecConstructor) {
+  folly::fbvector<std::pair<PathComponent, bool>> vec{
+      {PathComponent("zebra"), true},
+      {PathComponent("aardvark"), false},
+  };
+
+  auto m = PathMap<bool>{std::move(vec), CaseSensitivity::Sensitive};
+
+  // Make sure we can access both elements (i.e. confirm they were sorted).
+  ASSERT_EQ(true, m.at(PathComponent{"zebra"}));
+  ASSERT_EQ(false, m.at(PathComponent{"aardvark"}));
+}