New version of compact for UnordSet, OrdSet, UnordPWMap and OrdPWMap

Author: Kalashnikovni

sbg/map_entry.cpp

@@ -48,6 +48,16 @@ bool MapEntry::operator<(const MapEntry& other) const
 {
   return _perimeter.min() < other._perimeter.min();
 }
+
+MaybeMapEntry MapEntry::compact(const MapEntry& other) const
+{
+  MaybeMap compacted = _map.compact(other._map);
+  if (compacted) {
+    return MaybeMapEntry{compacted.value()};
+  }
+
+  return {};
+}
 
 } // namespace detail
 

sbg/map_entry.hpp

@@ -31,12 +31,18 @@
 #include "sbg/set.hpp"
 #include "sbg/set_perimeter.hpp"
 
+#include <optional>
+
 namespace SBG {
 
 namespace LIB {
 
 namespace detail {
 
+class MapEntry;
+
+using MaybeMapEntry = std::optional<MapEntry>;
+
 class MapEntry {
 public:
   MapEntry(const Set& s, const Expression& expr);
@@ -48,6 +54,8 @@ class MapEntry {
   bool operator==(const MapEntry& other) const;
   bool operator<(const MapEntry& other) const;
 
+  MaybeMapEntry compact(const MapEntry& other) const;
+
 private:
   Map _map;
   SetPerimeter _perimeter;

sbg/ord_pwmap.cpp

@@ -37,10 +37,10 @@ namespace detail {
 
 // Auxliary definitions --------------------------------------------------------
 
-class MapLess {
+class MapEntryLess {
 public:
-  bool operator()(const Map& a, const Map& b) const {
-    return a.domain().minElem() < b.domain().minElem();
+  bool operator()(const MapEntry& a, const MapEntry& b) const {
+    return a.map().domain().minElem() < b.map().domain().minElem();
   }
 };
 
@@ -735,9 +735,47 @@ Set OrdPWMap::lessImage(const OrdPWMap& other) const
   return traverse(other, LessImageCore{}).result();
 } 
 
-// TODO
 void OrdPWMap::compact()
 {
+  using MapSet = std::set<MapEntry, MapEntryLess>;
+
+  OrdMapCollection result;
+
+  if (!isEmpty()) {
+    MapSet set_result;
+    MapSet to_erase;
+    do {
+      MapSet new_set_result;
+      to_erase.clear();
+
+      MapSet::iterator ith = set_result.begin();
+      MapSet::iterator last = set_result.end();
+      for (; ith != last; ++ith) {
+        MapEntry ith_compact = *ith;
+        MapSet::iterator next = ith;
+        ++next;
+        for (; next != last; ++next) {
+          MaybeMapEntry new_compact = ith_compact.compact(*next);
+          if (new_compact) {
+            ith_compact = new_compact.value();
+            to_erase.insert(*next);
+          }
+        }
+
+        if (to_erase.find(ith_compact) == to_erase.end()) {
+          new_set_result.insert(ith_compact);
+        }
+      }
+
+      std::swap(set_result, new_set_result);
+    } while (!to_erase.empty());
+
+    for (const MapEntry& map_entry : set_result) {
+      result.push_back(map_entry);
+    }
+  }
+
+  _pieces = std::move(result);
 }
 
 } // namespace detail

sbg/ord_set.cpp

@@ -635,21 +635,23 @@ SetPerimeter OrderedSet::perimeter() const
 
 void OrderedSet::compact()
 {
+  using MDISet = std::set<MultiDimInter>;
+
   OrdMDICollection result;
 
   if (!isEmpty()) {
-    std::set<MultiDimInter> prev{_pieces.begin(), _pieces.end()};
-    std::set<MultiDimInter> actual = prev;
+    MDISet set_result{std::make_move_iterator(_pieces.begin())
+      , std::make_move_iterator(_pieces.end())};
+    MDISet to_erase;
     do {
-      prev = actual;
-      actual = std::set<MultiDimInter>{};
+      MDISet new_set_result;
+      to_erase.clear();
 
-      std::set<MultiDimInter>::iterator ith = prev.begin();
-      std::set<MultiDimInter>::iterator last = prev.end();
-      std::set<MultiDimInter> to_erase;
+      MDISet::iterator ith = set_result.begin();
+      MDISet::iterator last = set_result.end();
       for (; ith != last; ++ith) {
         MultiDimInter ith_compact = *ith;
-        std::set<MultiDimInter>::iterator next = ith;
+        MDISet::iterator next = ith;
         ++next;
         for (; next != last; ++next) {
           MaybeMDI new_compact = ith_compact.compact(*next);
@@ -660,13 +662,15 @@ void OrderedSet::compact()
         }
 
         if (to_erase.find(ith_compact) == to_erase.end()) {
-          actual.insert(ith_compact);
+          new_set_result.insert(ith_compact);
         }
-      } 
-    } while (actual != prev);
+      }
+
+      std::swap(set_result, new_set_result);
+    } while (!to_erase.empty());
 
-    for (const MultiDimInter& mdi : actual) {
-      result.push_back(mdi);
+    for (const MultiDimInter& m : set_result) {
+      result.push_back(m);
     }
   }
 

sbg/unord_pwmap.cpp

@@ -487,16 +487,15 @@ void UnordPWMap::compact()
   UnordMapCollection result;
 
   if (!isEmpty()) {
-    MapSet prev{std::make_move_iterator(_pieces.begin())
+    MapSet set_result{std::make_move_iterator(_pieces.begin())
       , std::make_move_iterator(_pieces.end())};
-    MapSet actual = prev;
+    MapSet to_erase;
     do {
-      prev = actual;
-      actual = MapSet{};
+      MapSet new_set_result;
+      to_erase.clear();
 
-      MapSet::iterator ith = prev.begin();
-      MapSet::iterator last = prev.end();
-      MapSet to_erase;
+      MapSet::iterator ith = set_result.begin();
+      MapSet::iterator last = set_result.end();
       for (; ith != last; ++ith) {
         Map ith_compact = *ith;
         MapSet::iterator next = ith;
@@ -510,12 +509,14 @@ void UnordPWMap::compact()
         }
 
         if (to_erase.find(ith_compact) == to_erase.end()) {
-          actual.insert(ith_compact);
+          new_set_result.insert(ith_compact);
         }
       }
-    } while (actual != prev);
 
-    for (const Map& m : actual) {
+      std::swap(set_result, new_set_result);
+    } while (!to_erase.empty());
+
+    for (const Map& m : set_result) {
       result.push_back(m);
     }
   }

sbg/unord_set.cpp

@@ -437,21 +437,23 @@ SetPerimeter UnorderedSet::perimeter() const
 
 void UnorderedSet::compact()
 {
+  using MDISet = std::set<MultiDimInter>;
+
   MDIUnordCollection result;
 
   if (!isEmpty()) {
-    std::set<MultiDimInter> prev{_pieces.begin(), _pieces.end()};
-    std::set<MultiDimInter> actual = prev;
+    MDISet set_result{std::make_move_iterator(_pieces.begin())
+      , std::make_move_iterator(_pieces.end())};
+    MDISet to_erase;
     do {
-      prev = actual;
-      actual = std::set<MultiDimInter>{};
+      MDISet new_set_result;
+      to_erase.clear();
 
-      std::set<MultiDimInter>::iterator ith = prev.begin();
-      std::set<MultiDimInter>::iterator last = prev.end();
-      std::set<MultiDimInter> to_erase;
+      MDISet::iterator ith = set_result.begin();
+      MDISet::iterator last = set_result.end();
       for (; ith != last; ++ith) {
         MultiDimInter ith_compact = *ith;
-        std::set<MultiDimInter>::iterator next = ith;
+        MDISet::iterator next = ith;
         ++next;
         for (; next != last; ++next) {
           MaybeMDI new_compact = ith_compact.compact(*next);
@@ -462,13 +464,15 @@ void UnorderedSet::compact()
         }
 
         if (to_erase.find(ith_compact) == to_erase.end()) {
-          actual.insert(ith_compact);
+          new_set_result.insert(ith_compact);
         }
-      } 
-    } while (actual != prev);
+      }
+
+      std::swap(set_result, new_set_result);
+    } while (!to_erase.empty());
 
-    for (const MultiDimInter& mdi : actual) {
-      result.push_back(mdi);
+    for (const MultiDimInter& m : set_result) {
+      result.push_back(m);
     }
   }