workaround possible optimisation that would alter the value of the erase_counter

The code is still not legal but works in practise.

fix similar to 5853673267

STL_Extension/include/CGAL/Compact_container.h

@@ -177,6 +177,8 @@ namespace internal {
     template <typename Element>
     static void set_erase_counter(Element &, unsigned int) {}
     template <typename Element>
+    static void restore_erase_counter(Element*, unsigned int) {}
+    template <typename Element>
     static void increment_erase_counter(Element &) {}
   };
 
@@ -192,12 +194,24 @@ namespace internal {
       return e.erase_counter();
     }
 
+    template <typename Element>
+    static unsigned int erase_counter(Element* e)
+    {
+      return e->erase_counter();
+    }
+
     template <typename Element>
     static void set_erase_counter(Element &e, unsigned int c)
     {
       e.set_erase_counter(c);
     }
 
+    template <typename Element>
+    static void restore_erase_counter(Element* e, unsigned int c)
+    {
+      e->set_erase_counter(c);
+    }
+
     template <typename Element>
     static void increment_erase_counter(Element &e)
     {
@@ -392,13 +406,18 @@ public:
   iterator
   emplace(const Args&... args)
   {
+    typedef internal::Erase_counter_strategy<
+      internal::has_increment_erase_counter<T>::value> EraseCounterStrategy;
+
     if (free_list == nullptr)
       allocate_new_block();
 
     pointer ret = free_list;
     free_list = clean_pointee(ret);
     std::size_t ts;
+    const auto ec = EraseCounterStrategy::erase_counter(ret);
     CGAL_USE(ts);
+
     if constexpr (Time_stamper::has_timestamp) {
       ts = ret->time_stamp();
     }
@@ -407,6 +426,7 @@ public:
       ret->set_time_stamp(ts);
     }
     Time_stamper::set_time_stamp(ret, time_stamp);
+    EraseCounterStrategy::restore_erase_counter(ret, ec);
     CGAL_assertion(type(ret) == USED);
     ++size_;
     return iterator(ret, 0);
@@ -414,6 +434,9 @@ public:
 
   iterator insert(const T &t)
   {
+    typedef internal::Erase_counter_strategy<
+      internal::has_increment_erase_counter<T>::value> EraseCounterStrategy;
+
     if (free_list == nullptr)
       allocate_new_block();
 
@@ -421,6 +444,8 @@ public:
     free_list = clean_pointee(ret);
     std::size_t ts;
     CGAL_USE(ts);
+    const auto ec = EraseCounterStrategy::erase_counter(ret);
+
     if constexpr (Time_stamper::has_timestamp) {
       ts = ret->time_stamp();
     }
@@ -429,6 +454,8 @@ public:
       ret->set_time_stamp(ts);
     }
     Time_stamper::set_time_stamp(ret, time_stamp);
+    EraseCounterStrategy::restore_erase_counter(ret, ec);
+
     CGAL_assertion(type(ret) == USED);
     ++size_;
     return iterator(ret, 0);
@@ -455,6 +482,7 @@ public:
 
     CGAL_precondition(type(&*x) == USED);
     EraseCounterStrategy::increment_erase_counter(*x);
+    const auto ec = EraseCounterStrategy::erase_counter(*x);
     std::size_t ts;
     CGAL_USE(ts);
     if constexpr (Time_stamper::has_timestamp) {
@@ -464,6 +492,8 @@ public:
     if constexpr (Time_stamper::has_timestamp) {
       x->set_time_stamp(ts);
     }
+    EraseCounterStrategy::restore_erase_counter(&*x, ec);
+
 
     put_on_free_list(&*x);
     --size_;

STL_Extension/include/CGAL/Concurrent_compact_container.h

@@ -80,6 +80,8 @@ namespace CCC_internal {
     template <typename Element>
     static void set_erase_counter(Element &, unsigned int) {}
     template <typename Element>
+    static void restore_erase_counter(Element*, unsigned int) {}
+    template <typename Element>
     static void increment_erase_counter(Element &) {}
   };
 
@@ -95,12 +97,24 @@ namespace CCC_internal {
       return e.erase_counter();
     }
 
+    template <typename Element>
+    static unsigned int erase_counter(Element* e)
+    {
+      return e->erase_counter();
+    }
+
     template <typename Element>
     static void set_erase_counter(Element &e, unsigned int c)
     {
       e.set_erase_counter(c);
     }
 
+    template <typename Element>
+    static void restore_erase_counter(Element* e, unsigned int c)
+    {
+      e->set_erase_counter(c);
+    }
+
     template <typename Element>
     static void increment_erase_counter(Element &e)
     {
@@ -350,7 +364,7 @@ public:
       CCC_internal::has_increment_erase_counter<T>::value> EraseCounterStrategy;
     FreeList * fl = get_free_list();
     pointer ret = init_insert(fl);
-    auto erase_counter = EraseCounterStrategy::erase_counter(*ret);;
+    auto erase_counter = EraseCounterStrategy::erase_counter(*ret);
     new (ret) value_type(args...);
     EraseCounterStrategy::set_erase_counter(*ret, erase_counter);
     return finalize_insert(ret, fl);
@@ -390,9 +404,10 @@ private:
 
     CGAL_precondition(type(x) == USED);
     EraseCounterStrategy::increment_erase_counter(*x);
-
+    auto erase_counter = EraseCounterStrategy::erase_counter(*x);
+    auto ptr = &*x;
     std::allocator_traits<allocator_type>::destroy(m_alloc, &*x);
-
+    EraseCounterStrategy::set_erase_counter(ptr, erase_counter);
     put_on_free_list(&*x, fl);
   }
 public: