Implemented ManyToMany bulk insert

RonPieket · RonPieket · commit 289b29566a5b · 2024-02-26T09:12:34.000-08:00
diff --git a/BinaryRelations/BinaryRelations.h b/BinaryRelations/BinaryRelations.h
@@ -285,15 +285,15 @@ template <typename LeftType, typename RightType> class OneToMany
         if(0 == pairs.size())
             return;
 
-        auto cmp = [](const Pair &a, const Pair &b)
+        auto compare_left_then_right = [](const Pair &a, const Pair &b)
         {
             if(a.left < b.left) return true;
             if(b.left < a.left) return false;
             return a.right < b.right;
         };
 
         std::vector<Pair> pairs_to_insert = pairs;  // Deep copy...
-        std::sort(pairs_to_insert.begin(), pairs_to_insert.end(), cmp); // ...so I can sort
+        std::sort(pairs_to_insert.begin(), pairs_to_insert.end(), compare_left_then_right); // ...so I can sort
 
         // ------------------------
         
@@ -310,7 +310,7 @@ template <typename LeftType, typename RightType> class OneToMany
 
         if (0 != pairs_to_erase.size())
         {
-            std::sort(pairs_to_erase.begin(), pairs_to_erase.end(), cmp);
+            std::sort(pairs_to_erase.begin(), pairs_to_erase.end(), compare_left_then_right);
 
             std::vector<RightType> right_to_erase;
             auto end_it = pairs_to_erase.cend();
@@ -358,12 +358,12 @@ template <typename LeftType, typename RightType> class OneToMany
             }
 
             // Insert them in one go
-            auto r2l_it = m_LeftToRight.find(left);
-            if (r2l_it != m_LeftToRight.end())
+            auto l2r_it = m_LeftToRight.find(left);
+            if (l2r_it != m_LeftToRight.end())
             {
-                auto *v = r2l_it->second;
-                auto temp = *v;
-                insertIntoSortedVector(&temp, &right_to_insert, v);
+                auto l2r_vec = l2r_it->second;
+                auto temp = *l2r_vec;   // Deep copy
+                insertIntoSortedVector(&temp, &right_to_insert, l2r_vec);
             }
             else
             {
@@ -459,15 +459,15 @@ template <typename LeftType, typename RightType> class OneToMany
         if(0 == pairs.size())
             return;
 
-        auto cmp = [](const Pair &a, const Pair &b)
+        auto compare_left_then_right = [](const Pair &a, const Pair &b)
         {
             if(a.left < b.left) return true;
             if(b.left < a.left) return false;
             return a.right < b.right;
         };
 
         std::vector<Pair> pairs_to_erase = pairs;  // Deep copy...
-        std::sort(pairs_to_erase.begin(), pairs_to_erase.end(), cmp); // ...so I can sort
+        std::sort(pairs_to_erase.begin(), pairs_to_erase.end(), compare_left_then_right); // ...so I can sort
 
         std::vector<RightType> right_to_erase;
         auto end_it = pairs_to_erase.cend();
@@ -785,9 +785,92 @@ template <typename LeftType, typename RightType> class ManyToMany
      */
     void insert(const std::vector<Pair> &pairs) noexcept
     {
-        for (auto pair : pairs)
+        if(0 == pairs.size())
+            return;
+
+        auto compare_left_then_right = [](const Pair &a, const Pair &b)
         {
-            insert(pair);
+            if(a.left < b.left) return true;
+            if(b.left < a.left) return false;
+            return a.right < b.right;
+        };
+
+        auto compare_right_then_left = [](const Pair &a, const Pair &b)
+        {
+            if(a.right < b.right) return true;
+            if(b.right < a.right) return false;
+            return a.left < b.left;
+        };
+
+        std::vector<Pair> pairs_to_insert = pairs;  // Deep copy...
+
+        // ------------------------
+
+        std::sort(pairs_to_insert.begin(), pairs_to_insert.end(), compare_left_then_right); // ...so I can sort
+
+        std::vector<RightType> right_to_insert;
+        auto it_end = pairs_to_insert.cend();
+        for (auto it = pairs_to_insert.cbegin(); it != it_end; )
+        {
+            // Collect all right values that have the same left value
+            right_to_insert.clear();
+            auto left = it->left;
+            while(it != it_end && it->left == left)
+            {
+                right_to_insert.push_back(it->right);
+                it++;
+            }
+
+            // Insert them in one go
+            auto l2r_it = m_LeftToRight.find(left);
+            if (l2r_it != m_LeftToRight.end())
+            {
+                auto l2r_vec = l2r_it->second;
+                auto temp = *l2r_vec;
+                m_Count -= l2r_vec->size();
+                insertIntoSortedVector(&temp, &right_to_insert, l2r_vec);
+                m_Count += l2r_vec->size();
+            }
+            else
+            {
+                // insert new value
+                auto l2r_vec = new std::vector<RightType>(right_to_insert);
+                m_LeftToRight[left] = l2r_vec;
+                m_Count += l2r_vec->size();
+            }
+        }
+
+        // ------------------------
+
+        std::sort(pairs_to_insert.begin(), pairs_to_insert.end(), compare_right_then_left);
+
+        std::vector<LeftType> left_to_insert;
+        it_end = pairs_to_insert.cend();
+        for (auto it = pairs_to_insert.cbegin(); it != it_end; )
+        {
+            // Collect all right values that have the same left value
+            left_to_insert.clear();
+            auto right = it->right;
+            while(it != it_end && it->right == right)
+            {
+                left_to_insert.push_back(it->left);
+                it++;
+            }
+
+            // Insert them in one go
+            auto r2l_it = m_RightToLeft.find(right);
+            if (r2l_it != m_RightToLeft.end())
+            {
+                auto r2l_vec = r2l_it->second;
+                auto temp = *r2l_vec;
+                insertIntoSortedVector(&temp, &left_to_insert, r2l_vec);
+            }
+            else
+            {
+                // insert new value
+                auto r2l_vec = new std::vector<LeftType>(left_to_insert);
+                m_RightToLeft[right] = r2l_vec;
+            }
         }
     }
 
diff --git a/TestManyToMany.h b/TestManyToMany.h
@@ -129,3 +129,101 @@ UTEST(TestManyToMany, AllRight)
 
     ASSERT_EQ(count, 4);
 }
+
+UTEST(TestManyToMany, BulkInsert)
+{
+    ManyToMany<int, std::string> m2m;
+    m2m.insert(1, "apple");
+    m2m.insert(1, "apricot");
+    m2m.insert(1, "avocado");
+    
+    m2m.insert(2, "banana");
+    m2m.insert(2, "blueberry");
+    m2m.insert(2, "blackberry");
+    
+    m2m.insert(3, "cherry");
+    m2m.insert(3, "coconut");
+    m2m.insert(3, "clementine");
+    
+    std::vector<ManyToMany<int, std::string>::Pair> vec;
+    // Add to existing left value
+    vec.push_back(ManyToMany<int, std::string>::Pair(3, "crabapple"));
+    vec.push_back(ManyToMany<int, std::string>::Pair(3, "cashew"));
+    // Completely new left right pairs
+    vec.push_back(ManyToMany<int, std::string>::Pair(10, "date"));
+    vec.push_back(ManyToMany<int, std::string>::Pair(10, "dewberry"));
+    // Existing right values, steal them
+    vec.push_back(ManyToMany<int, std::string>::Pair(10, "apricot"));
+    vec.push_back(ManyToMany<int, std::string>::Pair(10, "banana"));
+    vec.push_back(ManyToMany<int, std::string>::Pair(20, "avocado"));
+    vec.push_back(ManyToMany<int, std::string>::Pair(20, "apple"));
+    
+    m2m.insert(vec);
+
+    ASSERT_EQ(m2m.count(), 13);
+    //ASSERT_TRUE(isValid(m2m));
+
+    ASSERT_FALSE(m2m.contains(1, "apple"));
+    ASSERT_FALSE(m2m.contains(1, "apricot"));
+    ASSERT_FALSE(m2m.contains(1, "avocado"));
+    ASSERT_FALSE(m2m.contains(2, "banana"));
+
+    ASSERT_TRUE(m2m.contains(2, "blueberry"));
+    ASSERT_TRUE(m2m.contains(2, "blackberry"));
+    ASSERT_TRUE(m2m.contains(3, "cherry"));
+    ASSERT_TRUE(m2m.contains(3, "coconut"));
+    ASSERT_TRUE(m2m.contains(3, "clementine"));
+    
+    ASSERT_TRUE(m2m.contains(3, "crabapple"));
+    ASSERT_TRUE(m2m.contains(3, "cashew"));
+    ASSERT_TRUE(m2m.contains(10, "date"));
+    ASSERT_TRUE(m2m.contains(10, "dewberry"));
+    ASSERT_TRUE(m2m.contains(10, "apricot"));
+    ASSERT_TRUE(m2m.contains(10, "banana"));
+    ASSERT_TRUE(m2m.contains(20, "avocado"));
+    ASSERT_TRUE(m2m.contains(20, "apple"));
+}
+
+//UTEST(TestManyToMany, BulkErase)
+//{
+//    ManyToMany<int, std::string> mtm;
+//    mtm.insert(1, "apple");
+//    mtm.insert(1, "apricot");
+//    mtm.insert(1, "avocado");
+//    
+//    mtm.insert(2, "banana");
+//    mtm.insert(2, "blueberry");
+//    mtm.insert(2, "blackberry");
+//    
+//    mtm.insert(3, "cherry");
+//    mtm.insert(3, "coconut");
+//    mtm.insert(3, "clementine");
+//    
+//    std::vector<ManyToMany<int, std::string>::Pair> vec;
+//    // Erase all of left=1
+//    vec.push_back(ManyToMany<int, std::string>::Pair(1, "apple"));
+//    vec.push_back(ManyToMany<int, std::string>::Pair(1, "apricot"));
+//    vec.push_back(ManyToMany<int, std::string>::Pair(1, "avocado"));
+//    // Erase some of left=2
+//    vec.push_back(ManyToMany<int, std::string>::Pair(2, "banana"));
+//    vec.push_back(ManyToMany<int, std::string>::Pair(2, "blueberry"));
+//    // This pair is not in the set
+//    vec.push_back(ManyToMany<int, std::string>::Pair(1000, "zucchini"));
+//
+//    mtm.erase(vec);
+//
+//    ASSERT_EQ(mtm.count(), 4);
+//    //ASSERT_TRUE(isValid(mtm));
+//
+//    ASSERT_FALSE(mtm.contains(1, "apple"));
+//    ASSERT_FALSE(mtm.contains(1, "apricot"));
+//    ASSERT_FALSE(mtm.contains(1, "avocado"));
+//    ASSERT_FALSE(mtm.contains(2, "banana"));
+//    ASSERT_FALSE(mtm.contains(2, "blueberry"));
+//
+//    ASSERT_TRUE(mtm.contains(2, "blackberry"));
+//    ASSERT_TRUE(mtm.contains(3, "cherry"));
+//    ASSERT_TRUE(mtm.contains(3, "coconut"));
+//    ASSERT_TRUE(mtm.contains(3, "clementine"));
+//}
+
diff --git a/TestOneToMany.h b/TestOneToMany.h
@@ -109,6 +109,44 @@ bool isValid(const OneToMany<LeftType, RightType>& otm)
     return 0 == right_set.size();
 }
 
+UTEST(TestOneToMany, AllLeft)
+{
+    OneToMany<int, std::string> otm;
+    otm.insert(1, "apple");
+    otm.insert(1, "banana");
+    otm.insert(1, "cherry");
+    otm.insert(2, "date");
+    otm.insert(3, "elderberry");
+
+    int count = 0;
+    for (auto p : otm.allLeft())
+    {
+        (void)p; // Shut up compiler
+        count += 1;
+    }
+
+    ASSERT_EQ(count, 3);
+}
+
+UTEST(TestOneToMany, AllRight)
+{
+    OneToMany<int, std::string> otm;
+    otm.insert(1, "apple");
+    otm.insert(1, "banana");
+    otm.insert(1, "cherry");
+    otm.insert(2, "date");
+    otm.insert(3, "elderberry");
+
+    int count = 0;
+    for (auto p : otm.allRight())
+    {
+        (void)p; // Shut up compiler
+        count += 1;
+    }
+
+    ASSERT_EQ(count, 5);
+}
+
 UTEST(TestOneToMany, BulkInsert)
 {
     OneToMany<int, std::string> otm;
@@ -206,40 +244,3 @@ UTEST(TestOneToMany, BulkErase)
     ASSERT_TRUE(otm.contains(3, "clementine"));
 }
 
-UTEST(TestOneToMany, AllLeft)
-{
-    OneToMany<int, std::string> otm;
-    otm.insert(1, "apple");
-    otm.insert(1, "banana");
-    otm.insert(1, "cherry");
-    otm.insert(2, "date");
-    otm.insert(3, "elderberry");
-
-    int count = 0;
-    for (auto p : otm.allLeft())
-    {
-        (void)p; // Shut up compiler
-        count += 1;
-    }
-
-    ASSERT_EQ(count, 3);
-}
-
-UTEST(TestOneToMany, AllRight)
-{
-    OneToMany<int, std::string> otm;
-    otm.insert(1, "apple");
-    otm.insert(1, "banana");
-    otm.insert(1, "cherry");
-    otm.insert(2, "date");
-    otm.insert(3, "elderberry");
-
-    int count = 0;
-    for (auto p : otm.allRight())
-    {
-        (void)p; // Shut up compiler
-        count += 1;
-    }
-
-    ASSERT_EQ(count, 5);
-}
