phprus
diff --git a/‎include/ankerl/unordered_dense.h‎
Lines changed: 13 additions & 22 deletions b/‎include/ankerl/unordered_dense.h‎
Lines changed: 13 additions & 22 deletions
diff --git a/‎test/unit/pmr_move_with_allocators.cpp‎
Lines changed: 24 additions & 4 deletions b/‎test/unit/pmr_move_with_allocators.cpp‎
Lines changed: 24 additions & 4 deletions
@@ -598,24 +598,18 @@ class segmented_vector {
         : m_blocks(vec_alloc(alloc)) {}
 
     segmented_vector(segmented_vector&& other, Allocator alloc)
-        : m_blocks(vec_alloc(alloc)) {
-        if (other.get_allocator() == alloc) {
-            *this = std::move(other);
-        } else {
-            // Oh my, allocator is different so we need to copy everything.
-            append_everything_from(std::move(other));
-        }
+        : segmented_vector(alloc) {
+        *this = std::move(other);
     }
 
-    segmented_vector(segmented_vector&& other) noexcept
-        : m_blocks(std::move(other.m_blocks))
-        , m_size(std::exchange(other.m_size, {})) {}
-
     segmented_vector(segmented_vector const& other, Allocator alloc)
         : m_blocks(vec_alloc(alloc)) {
         append_everything_from(other);
     }
 
+    segmented_vector(segmented_vector&& other) noexcept
+        : segmented_vector(std::move(other), get_allocator()) {}
+
     segmented_vector(segmented_vector const& other) {
         append_everything_from(other);
     }
@@ -632,8 +626,12 @@ class segmented_vector {
     auto operator=(segmented_vector&& other) noexcept -> segmented_vector& {
         clear();
         dealloc();
-        m_blocks = std::move(other.m_blocks);
-        m_size = std::exchange(other.m_size, {});
+        if (other.get_allocator() == get_allocator()) {
+            m_blocks = std::move(other.m_blocks);
+            m_size = std::exchange(other.m_size, {});
+        } else {
+            append_everything_from(std::move(other));
+        }
         return *this;
     }
 
@@ -1169,15 +1167,8 @@ class table : public std::conditional_t<is_map_v<T>, base_table_type_map<T>, bas
         : table(std::move(other), other.m_values.get_allocator()) {}
 
     table(table&& other, allocator_type const& alloc) noexcept
-        : m_values(std::move(other.m_values), alloc)
-        , m_buckets(std::exchange(other.m_buckets, nullptr))
-        , m_num_buckets(std::exchange(other.m_num_buckets, 0))
-        , m_max_bucket_capacity(std::exchange(other.m_max_bucket_capacity, 0))
-        , m_max_load_factor(std::exchange(other.m_max_load_factor, default_max_load_factor))
-        , m_hash(std::exchange(other.m_hash, {}))
-        , m_equal(std::exchange(other.m_equal, {}))
-        , m_shifts(std::exchange(other.m_shifts, initial_shifts)) {
-        other.m_values.clear();
+        : m_values(alloc) {
+        *this = std::move(other);
     }
 
     table(std::initializer_list<value_type> ilist,
 
@@ -9,26 +9,46 @@
 #    if __linux__
 
 using int_str_map = ankerl::unordered_dense::pmr::map<int, std::string>;
+using int_str_map_segmented = ankerl::unordered_dense::pmr::segmented_map<int, std::string>;
+
+namespace {
 
 // creates a map and moves it out
+template <typename Map>
 auto return_hello_world(ANKERL_UNORDERED_DENSE_PMR::memory_resource* resource) {
-    int_str_map map_default_resource(resource);
+    Map map_default_resource(resource);
     map_default_resource[0] = "Hello";
     map_default_resource[1] = "World";
     return map_default_resource;
 }
 
-TEST_CASE("move_with_allocators") {
-    int_str_map map_default_resource(ANKERL_UNORDERED_DENSE_PMR::new_delete_resource());
+template <typename Map>
+auto doTest() {
+    Map map_default_resource(ANKERL_UNORDERED_DENSE_PMR::new_delete_resource());
 
     ANKERL_UNORDERED_DENSE_PMR::synchronized_pool_resource pool;
 
     // segfaults if m_buckets is reused
     {
-        map_default_resource = return_hello_world(&pool);
+        map_default_resource = return_hello_world<Map>(&pool);
+        REQUIRE(map_default_resource.contains(0));
+    }
+
+    {
+        Map map_default_resource_construct(return_hello_world<Map>(&pool), ANKERL_UNORDERED_DENSE_PMR::new_delete_resource());
         REQUIRE(map_default_resource.contains(0));
     }
 }
 
+TEST_CASE("move_with_allocators") {
+    doTest<int_str_map>();
+}
+
+TEST_CASE("move_with_allocators_segmented") {
+    doTest<int_str_map_segmented>();
+}
+
+} // namespace
+
 #    endif
 #endif