feat: implement roaring64_bitmap_overwrite

Author: Dr-Emann

include/roaring/roaring64.h

@@ -50,6 +50,18 @@ void roaring64_bitmap_free(roaring64_bitmap_t *r);
  */
 roaring64_bitmap_t *roaring64_bitmap_copy(const roaring64_bitmap_t *r);
 
+/**
+ * Copies a bitmap from src to dest. It is assumed that the pointer dest
+ * is to an already allocated bitmap. The content of the dest bitmap is
+ * freed/deleted.
+ *
+ * It might be preferable and simpler to call roaring64_bitmap_copy except
+ * that roaring64_bitmap_overwrite can save on memory allocations.
+ *
+ */
+void roaring64_bitmap_overwrite(roaring64_bitmap_t *dest,
+                                const roaring64_bitmap_t *src);
+
 /**
  * Creates a new bitmap of a pointer to N 64-bit integers.
  */

src/roaring64.c

@@ -273,6 +273,42 @@ roaring64_bitmap_t *roaring64_bitmap_copy(const roaring64_bitmap_t *r) {
     return result;
 }
 
+void roaring64_bitmap_overwrite(roaring64_bitmap_t *dest,
+                                const roaring64_bitmap_t *src) {
+    if (dest == src) {
+        return;
+    }
+
+    // Free dest's containers.
+    art_iterator_t it = art_init_iterator(&dest->art, /*first=*/true);
+    while (it.value != NULL) {
+        leaf_t leaf = (leaf_t)*it.value;
+        container_free(get_container(dest, leaf), get_typecode(leaf));
+        art_iterator_next(&it);
+    }
+    art_free(&dest->art);
+    roaring_free(dest->containers);
+
+    // Reinitialize dest.
+    art_init_cleared(&dest->art);
+    dest->flags = 0;
+    dest->first_free = 0;
+    dest->capacity = 0;
+    dest->containers = NULL;
+
+    // Copy src's containers into dest.
+    it = art_init_iterator((art_t *)&src->art, /*first=*/true);
+    while (it.value != NULL) {
+        leaf_t leaf = (leaf_t)*it.value;
+        uint8_t typecode = get_typecode(leaf);
+        container_t *container = get_copy_of_container(
+            get_container(src, leaf), &typecode, /*copy_on_write=*/false);
+        leaf_t dest_leaf = add_container(dest, container, typecode);
+        art_insert(&dest->art, it.key, (art_val_t)dest_leaf);
+        art_iterator_next(&it);
+    }
+}
+
 /**
  * Steal the containers from a 32-bit bitmap and insert them into a 64-bit
  * bitmap (with an offset)

tests/roaring64_unit.cpp

@@ -114,6 +114,45 @@ DEFINE_TEST(test_copy) {
     roaring64_bitmap_free(r2);
 }
 
+DEFINE_TEST(test_overwrite) {
+    roaring64_bitmap_t* r1 = roaring64_bitmap_create();
+    roaring64_bitmap_add(r1, 0);
+    roaring64_bitmap_add(r1, 10000);
+    roaring64_bitmap_add(r1, 200000);
+
+    roaring64_bitmap_t* r2 = roaring64_bitmap_create();
+    roaring64_bitmap_add(r2, 123);
+
+    roaring64_bitmap_overwrite(r2, r1);
+    assert_r64_valid(r2);
+    assert_true(roaring64_bitmap_contains(r2, 0));
+    assert_true(roaring64_bitmap_contains(r2, 10000));
+    assert_true(roaring64_bitmap_contains(r2, 200000));
+    assert_false(roaring64_bitmap_contains(r2, 123));
+
+    // Modifying src after overwrite does not affect dest.
+    roaring64_bitmap_remove(r1, 200000);
+    roaring64_bitmap_add(r1, 300000);
+    assert_r64_valid(r1);
+    assert_true(roaring64_bitmap_contains(r2, 200000));
+    assert_false(roaring64_bitmap_contains(r2, 300000));
+
+    // Overwriting with an empty bitmap clears dest.
+    roaring64_bitmap_t* empty = roaring64_bitmap_create();
+    roaring64_bitmap_overwrite(r2, empty);
+    assert_r64_valid(r2);
+    assert_true(roaring64_bitmap_is_empty(r2));
+
+    // Self-overwrite is a no-op.
+    roaring64_bitmap_overwrite(r1, r1);
+    assert_r64_valid(r1);
+    assert_true(roaring64_bitmap_contains(r1, 300000));
+
+    roaring64_bitmap_free(empty);
+    roaring64_bitmap_free(r1);
+    roaring64_bitmap_free(r2);
+}
+
 DEFINE_TEST(test_move_from_roaring32) {
     {
         // Empty bitmap
@@ -2336,6 +2375,7 @@ int main() {
         cmocka_unit_test(test_remove_many_issue_742B),
         cmocka_unit_test(fuzz_deserializer),
         cmocka_unit_test(test_copy),
+        cmocka_unit_test(test_overwrite),
         cmocka_unit_test(test_from_range),
         cmocka_unit_test(test_move_from_roaring32),
         cmocka_unit_test(test_of_ptr),