2 0 for real

.gitignore

@@ -1,3 +1,5 @@
 target
 .DS_Store
-.idea
+.idea
+README.md.tmp
+Cargo.toml.tmp

Makefile

@@ -15,7 +15,7 @@ test:
 croaring_release_url_base = https://github.com/RoaringBitmap/CRoaring/releases/download
 
 # Fetch the c source amalgamation from a tagged CRoaring release (like `make version=0.9.3 update_croaring`)
-update_croaring: download_croaring bindgen
+update_croaring: download_croaring bindgen update_readme_croaring_version update_croaring_sys_version
 
 download_croaring:
 	rm -f '$(croaring_source)/roaring.c' '$(croaring_source)/roaring.h' '$(croaring_source)/roaring.hh'
@@ -35,6 +35,19 @@ bindgen:
 			-o bindgen_bundled_version.rs \
 			roaring.h
 
+
+# sed -i is a GNU extension, so we use a temporary file explicitly
+update_readme_croaring_version:
+	@echo "Updating README.md with CRoaring version $(version)"
+	@sed -r -e 's_\[CRoaring version `[0-9]+\.[0-9]+\.[0-9]+`\]\([^\)]+\)_[CRoaring version `$(version)`](https://github.com/RoaringBitmap/CRoaring/releases/tag/v$(version))_' README.md > README.md.tmp
+	@mv README.md.tmp README.md
+
+# We don't always want to update the version of croaring-sys dependency in croaring, but we always want to update croaring-sys
+update_croaring_sys_version:
+	@echo "Updating croaring-sys version in Cargo.toml to $(version)"
+	@sed -r -e 's/^version = ".*"/version = "$(version)"/' croaring-sys/Cargo.toml > croaring-sys/Cargo.toml.tmp
+	@mv croaring-sys/Cargo.toml.tmp croaring-sys/Cargo.toml
+
 # Build a c program to (re)generate the example serialized files for testing
 test_serialization_files:
 	cd croaring/tests/data/ && \

README.md

@@ -124,3 +124,10 @@ cargo bench
 ### Documentation
 
 Current documentation is available at https://docs.rs/croaring/latest/croaring/
+
+## CRoaring Version
+
+This crate uses [CRoaring version `4.1.0`](https://github.com/RoaringBitmap/CRoaring/releases/tag/v4.1.0).
+The version of this crate does not necessarily match the version of CRoaring: the major version of the crate is only
+incremented when there are breaking changes in the Rust API: It is possible (and has happened) that breaking changes
+in the CRoaring C API do not necessitate a major version bump in this crate.

croaring-sys/CRoaring/bindgen_bundled_version.rs

@@ -5,6 +5,14 @@ pub const ROARING_VERSION_MAJOR: _bindgen_ty_1 = 4;
 pub const ROARING_VERSION_MINOR: _bindgen_ty_1 = 0;
 pub const ROARING_VERSION_REVISION: _bindgen_ty_1 = 0;
 pub type _bindgen_ty_1 = ::core::ffi::c_uint;
+extern "C" {
+    #[doc = " result might be undefined when input_num is zero"]
+    pub fn roaring_trailing_zeroes(input_num: ::core::ffi::c_ulonglong) -> ::core::ffi::c_int;
+}
+extern "C" {
+    #[doc = " result might be undefined when input_num is zero"]
+    pub fn roaring_leading_zeroes(input_num: ::core::ffi::c_ulonglong) -> ::core::ffi::c_int;
+}
 #[doc = " Roaring arrays are array-based key-value pairs having containers as values\n and 16-bit integer keys. A roaring bitmap  might be implemented as such."]
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
@@ -73,14 +81,6 @@ pub struct roaring_container_iterator_s {
 }
 #[doc = " Roaring-internal type used to iterate within a roaring container."]
 pub type roaring_container_iterator_t = roaring_container_iterator_s;
-extern "C" {
-    #[doc = " result might be undefined when input_num is zero"]
-    pub fn roaring_trailing_zeroes(input_num: ::core::ffi::c_ulonglong) -> ::core::ffi::c_int;
-}
-extern "C" {
-    #[doc = " result might be undefined when input_num is zero"]
-    pub fn roaring_leading_zeroes(input_num: ::core::ffi::c_ulonglong) -> ::core::ffi::c_int;
-}
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
 pub struct bitset_s {
@@ -925,6 +925,10 @@ extern "C" {
     #[doc = " Remove all values in range [min, max]."]
     pub fn roaring64_bitmap_remove_range_closed(r: *mut roaring64_bitmap_t, min: u64, max: u64);
 }
+extern "C" {
+    #[doc = " Empties the bitmap."]
+    pub fn roaring64_bitmap_clear(r: *mut roaring64_bitmap_t);
+}
 extern "C" {
     #[doc = " Returns true if the provided value is present."]
     pub fn roaring64_bitmap_contains(r: *const roaring64_bitmap_t, val: u64) -> bool;
@@ -977,6 +981,14 @@ extern "C" {
         max: u64,
     ) -> u64;
 }
+extern "C" {
+    #[doc = " Returns the number of elements in the range [min, max]"]
+    pub fn roaring64_bitmap_range_closed_cardinality(
+        r: *const roaring64_bitmap_t,
+        min: u64,
+        max: u64,
+    ) -> u64;
+}
 extern "C" {
     #[doc = " Returns true if the bitmap is empty (cardinality is zero)."]
     pub fn roaring64_bitmap_is_empty(r: *const roaring64_bitmap_t) -> bool;

croaring-sys/CRoaring/roaring.c

@@ -1,5 +1,5 @@
 // !!! DO NOT EDIT - THIS IS AN AUTO-GENERATED FILE !!!
-// Created by amalgamation.sh on 2024-05-13T21:29:25Z
+// Created by amalgamation.sh on 2024-07-03T21:30:32Z
 
 /*
  * The CRoaring project is under a dual license (Apache/MIT).
@@ -10770,7 +10770,7 @@ static bool art_node_iterator_lower_bound(const art_node_t *node,
 }
 
 art_iterator_t art_init_iterator(const art_t *art, bool first) {
-    art_iterator_t iterator = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+    art_iterator_t iterator = CROARING_ZERO_INITIALIZER;
     if (art->root == NULL) {
         return iterator;
     }
@@ -10793,8 +10793,11 @@ bool art_iterator_lower_bound(art_iterator_t *iterator,
         // a valid key. Start from the root.
         iterator->frame = 0;
         iterator->depth = 0;
-        return art_node_iterator_lower_bound(art_iterator_node(iterator),
-                                             iterator, key);
+        art_node_t *root = art_iterator_node(iterator);
+        if (root == NULL) {
+            return false;
+        }
+        return art_node_iterator_lower_bound(root, iterator, key);
     }
     int compare_result =
         art_compare_prefix(iterator->key, 0, key, 0, ART_KEY_BYTES);
@@ -10827,15 +10830,15 @@ bool art_iterator_lower_bound(art_iterator_t *iterator,
 }
 
 art_iterator_t art_lower_bound(const art_t *art, const art_key_chunk_t *key) {
-    art_iterator_t iterator = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+    art_iterator_t iterator = CROARING_ZERO_INITIALIZER;
     if (art->root != NULL) {
         art_node_iterator_lower_bound(art->root, &iterator, key);
     }
     return iterator;
 }
 
 art_iterator_t art_upper_bound(const art_t *art, const art_key_chunk_t *key) {
-    art_iterator_t iterator = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+    art_iterator_t iterator = CROARING_ZERO_INITIALIZER;
     if (art->root != NULL) {
         if (art_node_iterator_lower_bound(art->root, &iterator, key) &&
             art_compare_keys(iterator.key, key) == 0) {
@@ -19469,7 +19472,7 @@ roaring_bitmap_t *roaring_bitmap_of(size_t n_args, ...) {
     // todo: could be greatly optimized but we do not expect this call to ever
     // include long lists
     roaring_bitmap_t *answer = roaring_bitmap_create();
-    roaring_bulk_context_t context = {0, 0, 0, 0};
+    roaring_bulk_context_t context = CROARING_ZERO_INITIALIZER;
     va_list ap;
     va_start(ap, n_args);
     for (size_t i = 0; i < n_args; i++) {
@@ -20811,7 +20814,7 @@ roaring_bitmap_t *roaring_bitmap_deserialize(const void *buf) {
         if (bitmap == NULL) {
             return NULL;
         }
-        roaring_bulk_context_t context = {0, 0, 0, 0};
+        roaring_bulk_context_t context = CROARING_ZERO_INITIALIZER;
         for (uint32_t i = 0; i < card; i++) {
             // elems may not be aligned, read with memcpy
             uint32_t elem;
@@ -20854,7 +20857,7 @@ roaring_bitmap_t *roaring_bitmap_deserialize_safe(const void *buf,
         if (bitmap == NULL) {
             return NULL;
         }
-        roaring_bulk_context_t context = {0, 0, 0, 0};
+        roaring_bulk_context_t context = CROARING_ZERO_INITIALIZER;
         for (uint32_t i = 0; i < card; i++) {
             // elems may not be aligned, read with memcpy
             uint32_t elem;
@@ -22780,6 +22783,9 @@ roaring64_bitmap_t *roaring64_bitmap_create(void) {
 }
 
 void roaring64_bitmap_free(roaring64_bitmap_t *r) {
+    if (!r) {
+        return;
+    }
     art_iterator_t it = art_init_iterator(&r->art, /*first=*/true);
     while (it.value != NULL) {
         leaf_t *leaf = (leaf_t *)it.value;
@@ -22856,7 +22862,7 @@ roaring64_bitmap_t *roaring64_bitmap_of_ptr(size_t n_args,
 
 roaring64_bitmap_t *roaring64_bitmap_of(size_t n_args, ...) {
     roaring64_bitmap_t *r = roaring64_bitmap_create();
-    roaring64_bulk_context_t context = {0, 0, 0, 0, 0, 0, 0};
+    roaring64_bulk_context_t context = CROARING_ZERO_INITIALIZER;
     va_list ap;
     va_start(ap, n_args);
     for (size_t i = 0; i < n_args; i++) {
@@ -22949,7 +22955,7 @@ void roaring64_bitmap_add_many(roaring64_bitmap_t *r, size_t n_args,
         return;
     }
     const uint64_t *end = vals + n_args;
-    roaring64_bulk_context_t context = {0, 0, 0, 0, 0, 0, 0};
+    roaring64_bulk_context_t context = CROARING_ZERO_INITIALIZER;
     for (const uint64_t *current_val = vals; current_val != end;
          current_val++) {
         roaring64_bitmap_add_bulk(r, &context, *current_val);
@@ -23273,7 +23279,7 @@ void roaring64_bitmap_remove_many(roaring64_bitmap_t *r, size_t n_args,
         return;
     }
     const uint64_t *end = vals + n_args;
-    roaring64_bulk_context_t context = {0, 0, 0, 0, 0, 0, 0};
+    roaring64_bulk_context_t context = CROARING_ZERO_INITIALIZER;
     for (const uint64_t *current_val = vals; current_val != end;
          current_val++) {
         roaring64_bitmap_remove_bulk(r, &context, *current_val);
@@ -23339,6 +23345,10 @@ void roaring64_bitmap_remove_range_closed(roaring64_bitmap_t *r, uint64_t min,
     remove_range_closed_at(art, max_high48, 0, max_low16);
 }
 
+void roaring64_bitmap_clear(roaring64_bitmap_t *r) {
+    roaring64_bitmap_remove_range_closed(r, 0, UINT64_MAX);
+}
+
 uint64_t roaring64_bitmap_get_cardinality(const roaring64_bitmap_t *r) {
     art_iterator_t it = art_init_iterator(&r->art, /*first=*/true);
     uint64_t cardinality = 0;
@@ -23356,7 +23366,17 @@ uint64_t roaring64_bitmap_range_cardinality(const roaring64_bitmap_t *r,
     if (min >= max) {
         return 0;
     }
-    max--;  // A closed range is easier to work with.
+    // Convert to a closed range
+    // No underflow here: passing the above condition implies min < max, so
+    // there is a number less than max
+    return roaring64_bitmap_range_closed_cardinality(r, min, max - 1);
+}
+
+uint64_t roaring64_bitmap_range_closed_cardinality(const roaring64_bitmap_t *r,
+                                                   uint64_t min, uint64_t max) {
+    if (min > max) {
+        return 0;
+    }
 
     uint64_t cardinality = 0;
     uint8_t min_high48[ART_KEY_BYTES];