added insert_and_visit and similar operations to concurrent containers (#283)

test/cfoa/emplace_tests.cpp

@@ -53,6 +53,34 @@ namespace {
     return x.emplace_or_cvisit(v.first.x_, v.second.x_, f);
   }
 
+  template <typename Container, typename Value, typename F1, typename F2>
+  bool member_emplace_and_visit(Container& x, Value& v, F1 f1, F2 f2)
+  {
+    return x.emplace_and_visit(v.x_, f1, f2);
+  }
+
+  template <
+    typename Container, typename Key, typename Value, typename F1, typename F2>
+  bool member_emplace_and_visit(
+    Container& x, std::pair<Key, Value>& v, F1 f1, F2 f2)
+  {
+    return x.emplace_and_visit(v.first.x_, v.second.x_, f1, f2);
+  }
+
+  template <typename Container, typename Value, typename F1, typename F2>
+  bool member_emplace_and_cvisit(Container& x, Value& v, F1 f1, F2 f2)
+  {
+    return x.emplace_and_cvisit(v.x_, f1, f2);
+  }
+
+  template <
+    typename Container, typename Key, typename Value, typename F1, typename F2>
+  bool member_emplace_and_cvisit(
+    Container& x, std::pair<Key, Value>& v, F1 f1, F2 f2)
+  {
+    return x.emplace_and_cvisit(v.first.x_, v.second.x_, f1, f2);
+  }
+
   struct lvalue_emplacer_type
   {
     template <class T, class X> void call_impl(std::vector<T>& values, X& x)
@@ -133,6 +161,55 @@ namespace {
     }
   } lvalue_emplace_or_cvisit;
 
+  struct lvalue_emplace_and_cvisit_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      static constexpr auto value_type_cardinality = 
+        value_cardinality<typename X::value_type>::value;
+
+      // concurrent_flat_set visit is always const access
+      using arg_type = typename std::conditional<
+        std::is_same<typename X::key_type, typename X::value_type>::value,
+        typename X::value_type const,
+        typename X::value_type
+      >::type;
+
+      std::atomic<std::uint64_t> num_inserts{0}, num_inserts_internal{0};
+      std::atomic<std::uint64_t> num_invokes{0};
+      thread_runner(values,
+        [&x, &num_inserts, &num_inserts_internal, &num_invokes](boost::span<T> s) {
+        for (auto& r : s) {
+          bool b = member_emplace_and_cvisit(
+            x, r,
+            [&num_inserts_internal](arg_type& v) {
+              (void)v;
+              ++num_inserts_internal;
+            },
+            [&num_invokes](typename X::value_type const& v) {
+              (void)v;
+              ++num_invokes;
+            });
+
+          if (b) {
+            ++num_inserts;
+          }
+        }
+      });
+
+      BOOST_TEST_EQ(num_inserts, num_inserts_internal);
+      BOOST_TEST_EQ(num_inserts, x.size());
+      BOOST_TEST_EQ(num_invokes, values.size() - x.size());
+
+      BOOST_TEST_EQ(
+        raii::default_constructor, value_type_cardinality * values.size());
+      BOOST_TEST_EQ(raii::copy_constructor, 0u);
+      BOOST_TEST_GE(raii::move_constructor, value_type_cardinality * x.size());
+      BOOST_TEST_EQ(raii::move_assignment, 0u);
+      BOOST_TEST_EQ(raii::copy_assignment, 0u);
+    }
+  } lvalue_emplace_and_cvisit;
+
   struct lvalue_emplace_or_visit_type
   {
     template <class T, class X> void operator()(std::vector<T>& values, X& x)
@@ -176,6 +253,55 @@ namespace {
     }
   } lvalue_emplace_or_visit;
 
+  struct lvalue_emplace_and_visit_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      static constexpr auto value_type_cardinality = 
+        value_cardinality<typename X::value_type>::value;
+
+      // concurrent_flat_set visit is always const access
+      using arg_type = typename std::conditional<
+        std::is_same<typename X::key_type, typename X::value_type>::value,
+        typename X::value_type const,
+        typename X::value_type
+      >::type;
+
+      std::atomic<std::uint64_t> num_inserts{0}, num_inserts_internal{0};
+      std::atomic<std::uint64_t> num_invokes{0};
+      thread_runner(values,
+        [&x, &num_inserts, &num_inserts_internal, &num_invokes](boost::span<T> s) {
+        for (auto& r : s) {
+          bool b = member_emplace_and_visit(
+            x, r,
+            [&num_inserts_internal](arg_type& v) {
+              (void)v;
+              ++num_inserts_internal;
+            },
+            [&num_invokes](arg_type& v) {
+              (void)v;
+              ++num_invokes;
+            });
+
+          if (b) {
+            ++num_inserts;
+          }
+        }
+      });
+
+      BOOST_TEST_EQ(num_inserts, num_inserts_internal);
+      BOOST_TEST_EQ(num_inserts, x.size());
+      BOOST_TEST_EQ(num_invokes, values.size() - x.size());
+
+      BOOST_TEST_EQ(
+        raii::default_constructor, value_type_cardinality * values.size());
+      BOOST_TEST_EQ(raii::copy_constructor, 0u);
+      BOOST_TEST_GE(raii::move_constructor, value_type_cardinality * x.size());
+      BOOST_TEST_EQ(raii::move_assignment, 0u);
+      BOOST_TEST_EQ(raii::copy_assignment, 0u);
+    }
+  } lvalue_emplace_and_visit;
+
   struct copy_emplacer_type
   {
     template <class T, class X> void operator()(std::vector<T>& values, X& x)
@@ -312,6 +438,13 @@ UNORDERED_TEST(
    (lvalue_emplace_or_cvisit)(lvalue_emplace_or_visit)(copy_emplacer)(move_emplacer))
   ((default_generator)(sequential)(limited_range)))
 
+UNORDERED_TEST(
+  emplace,
+  ((map)(node_map)(set)(node_set))
+  ((value_type_generator_factory)(init_type_generator_factory))
+  ((lvalue_emplace_and_cvisit)(lvalue_emplace_and_visit))
+  ((default_generator)(sequential)(limited_range)))
+
 // clang-format on
 
 namespace {