croaring

https://docs.rs/croaring/2.5.2
Admin
A Rust wrapper for CRoaring that provides compressed bitmaps which act like an efficient set of...
Tokens:524,474
Snippets:3,351
Trust Score:9.7
Update:7 months ago
Show doc for...
Tokens:
Raw
### Get Cursor to First Value

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap64/struct.Bitmap64View.html

Shows how to get a cursor pointing to the first value in a Bitmap64. Cursors allow efficient traversal.

```rust
use croaring::Bitmap64;

let bitmap = Bitmap64::of(&[5, 10, 15]);
let mut cursor = bitmap.cursor();

assert_eq!(cursor.current(), Some(&5));
cursor.advance();
assert_eq!(cursor.current(), Some(&10));
```

--------------------------------

### Create Bitmap from a Range of Integers

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap/struct.Bitmap.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates creating a Bitmap from various range types, including exclusive (`start..end`), inclusive (`start..=end`), and tuple-based ranges with bounds (`(Bound::Excluded(start), Bound::Excluded(end))`). The examples show how to collect the iterator of the created bitmaps into a vector to verify their contents.

```rust
use std::ops::Bound;
use croaring::Bitmap;

let bitmap1 = Bitmap::from_range(5..10);
assert_eq!(bitmap1.iter().collect::<Vec<_>>(), [5, 6, 7, 8, 9]);

let bitmap2 = Bitmap::from_range(5..=7);
assert_eq!(bitmap2.iter().collect::<Vec<_>>(), [5, 6, 7]);

let bitmap3 = Bitmap::from_range((Bound::Excluded(2), Bound::Excluded(6)));
assert_eq!(bitmap3.iter().collect::<Vec<_>>(), [3, 4, 5]);
```

--------------------------------

### Initialize and Resize Bitset

Source: https://docs.rs/croaring/2.5.2/croaring/bitset/struct.Bitset.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to create a new Bitset instance using default or specific sizes, and how to resize the underlying storage using word-based allocation.

```rust
use croaring::Bitset;
let bitset = Bitset::new();
assert_eq!(bitset.capacity(), 0);

let mut bitset = Bitset::with_size(100);
assert!(bitset.capacity() >= 100);

bitset.resize_words(2, true);
assert_eq!(bitset.iter().collect::<Vec<_>>(), (64..128).collect::<Vec<_>>());
```

--------------------------------

### Example Usage of BitAnd Trait with Bitmap (Rust)

Source: https://docs.rs/croaring/2.5.2/src/croaring/bitmap/ops.rs.html?search=std%3A%3Avec

This code snippet demonstrates the usage of the `BitAnd` trait with the `Bitmap` type. It shows how to create two bitmaps, add elements to them, and then perform a bitwise AND operation, assigning the result to a new `Bitmap` variable. The example includes necessary imports and setup.

```rust
impl_binop! {
    impl BitAnd {
        type Output = Bitmap;

        /// Syntactic sugar for `.and`
        ///
        /// # Examples
        ///
        /// ```
        /// use croaring::Bitmap;
        ///
        /// let mut bitmap1 = Bitmap::new();
        /// bitmap1.add(1);
        ///
        /// let mut bitmap2 = Bitmap::new();
        /// bitmap2.add(1);
        /// bitmap2.add(2);
        ///
        // Note: The actual function body for `fn.and` is not shown here, 
        // but the macro usage implies its existence and expected signature.
        // The example is cut short in the provided text.
    }
}
```

--------------------------------

### Bitmap64 Basic Operations

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap64/struct.Bitmap64View.html

Demonstrates basic operations like creating a bitmap, checking for element containment, and adding elements.

```APIDOC
## Bitmap64 Basic Operations

### Description
Demonstrates basic operations like creating a bitmap, checking for element containment, and adding elements.

### Method
N/A (Illustrative Example)

### Endpoint
N/A

### Parameters
N/A

### Request Example
```rust
use croaring::Bitmap64;
let mut bitmap = Bitmap64::new();
assert!(!bitmap.contains(1));itmap.add(1);
assert!(bitmap.contains(1));
```

### Response
N/A
```

--------------------------------

### Get Bitmap64 Cursor to Last Element (Rust)

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap64/struct.Bitmap64.html?search=

Obtains a cursor pointing to the last element in a Bitmap64. This is useful for iterating backwards or starting traversals from the end of the bitmap.

```Rust
use croaring::Bitmap64;
let bitmap = Bitmap64::of(&[10, 20, 30]);
let mut cursor = bitmap.cursor_to_last();
assert_eq!(cursor.current(), Some(&30));
```

--------------------------------

### Initialize and Resize Bitset

Source: https://docs.rs/croaring/2.5.2/croaring/bitset/struct.Bitset.html?search=std%3A%3Avec

Demonstrates how to create a new Bitset instance, initialize it with a specific size, and resize it using 64-bit word increments.

```rust
use croaring::Bitset;
let bitset = Bitset::new();
assert_eq!(bitset.capacity(), 0);

let bitset = Bitset::with_size(100);
assert!(bitset.capacity() >= 100);

let mut bitset = Bitset::new();
bitset.resize_words(1, false);
bitset.resize_words(2, true);
```

--------------------------------

### Bitmap Select Operation in Rust

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap/struct.BitmapView.html

Illustrates the `select` method for `croaring::Bitmap`, which retrieves the element at a specific position (rank) within the bitmap. This is the inverse operation of `position` and `rank`. The example shows how to get elements based on their index.

```rust
use croaring::Bitmap;

let bitmap: Bitmap = (5..10).collect();

assert_eq!(bitmap.select(0), Some(5));
assert_eq!(bitmap.select(1), Some(6));
assert_eq!(bitmap.select(2), Some(7));
assert_eq!(bitmap.select(3), Some(8));
assert_eq!(bitmap.select(4), Some(9));
assert_eq!(bitmap.select(5), None);
```

--------------------------------

### Create a new Bitmap

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap/struct.Bitmap.html?search=

Demonstrates how to create a new, empty Bitmap using `Bitmap::new()` and verify its initial state with `is_empty()`.

```rust
use croaring::Bitmap;

let bitmap = Bitmap::new();

assert!(bitmap.is_empty());
```

--------------------------------

### Converting Between Iterator and Cursor

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap64/struct.Bitmap64Iterator.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples of converting between Bitmap64Iterator and Bitmap64Cursor, which allows for flexible navigation and state management within the bitmap.

```rust
use croaring::bitmap64::{Bitmap64, Bitmap64Iterator};

let mut bitmap = Bitmap64::of(&[1, 2, 3]);
let mut cursor = bitmap.cursor();
let mut iter = Bitmap64Iterator::from(cursor);
assert_eq!(iter.next(), Some(1));
```

```rust
use croaring::bitmap64::{Bitmap64, Bitmap64Cursor};
let mut bitmap = Bitmap64::of(&[1, 2, 3]);
let mut iter = bitmap.iter();
iter.next();
let mut cursor: Bitmap64Cursor = iter.into();
assert_eq!(cursor.current(), Some(2));
```

--------------------------------

### Get Maximum Set Bit Index in Bitset (Rust)

Source: https://docs.rs/croaring/2.5.2/src/croaring/bitset/imp.rs.html

Retrieves the index of the largest set bit in the bitset. Returns 0 if the bitset is empty. This function relies on the underlying C FFI implementation and includes an example demonstrating its usage.

```Rust
pub fn maximum(&self) -> usize {
    unsafe { ffi::bitset_maximum(&self.bitset) }
}
```

--------------------------------

### Initialize and Configure Bitmap

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap/struct.Bitmap.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to create a new, empty Bitmap instance, optionally providing a container capacity hint for performance optimization.

```rust
use croaring::Bitmap;

let bitmap = Bitmap::new();
assert!(bitmap.is_empty());

let bitmap_with_capacity = Bitmap::with_container_capacity(1_000);
assert!(bitmap_with_capacity.is_empty());
```

--------------------------------

### Create Bitmap with Container Capacity

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap/struct.Bitmap.html?search=

Shows how to initialize a Bitmap with a specified container capacity hint using `Bitmap::with_container_capacity()`. This is a performance optimization and does not affect the number of elements stored.

```rust
use croaring::Bitmap;

let bitmap = Bitmap::with_container_capacity(1_000);

assert!(bitmap.is_empty());
```

--------------------------------

### Get Type ID of an Object

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap/struct.BitmapIterator.html

Gets the `TypeId` of `self`. This is useful for runtime type identification.

```Rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Bitmap Statistics and Optimization Example

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap/struct.Bitmap.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates collecting a range of numbers into a Bitmap, retrieving its statistics, optimizing it for run containers, and then retrieving updated statistics. Shows how container types and byte usage change after optimization.

```rust
use croaring::Bitmap;

let mut bitmap: Bitmap = (1..100).collect();
let statistics = bitmap.statistics();

assert_eq!(statistics.n_containers, 1);
assert_eq!(statistics.n_array_containers, 1);
assert_eq!(statistics.n_run_containers, 0);
assert_eq!(statistics.n_bitset_containers, 0);
assert_eq!(statistics.n_values_array_containers, 99);
assert_eq!(statistics.n_values_run_containers, 0);
assert_eq!(statistics.n_values_bitset_containers, 0);
assert_eq!(statistics.n_bytes_array_containers, 198);
assert_eq!(statistics.n_bytes_run_containers, 0);
assert_eq!(statistics.n_bytes_bitset_containers, 0);
assert_eq!(statistics.max_value, 99);
assert_eq!(statistics.min_value, 1);
assert_eq!(statistics.cardinality, 99);
itmap.run_optimize();
let statistics = bitmap.statistics();

assert_eq!(statistics.n_containers, 1);
assert_eq!(statistics.n_array_containers, 0);
assert_eq!(statistics.n_run_containers, 1);
assert_eq!(statistics.n_bitset_containers, 0);
assert_eq!(statistics.n_values_array_containers, 0);
assert_eq!(statistics.n_values_run_containers, 99);
assert_eq!(statistics.n_values_bitset_containers, 0);
assert_eq!(statistics.n_bytes_array_containers, 0);
assert_eq!(statistics.n_bytes_run_containers, 6);
assert_eq!(statistics.n_bytes_bitset_containers, 0);
assert_eq!(statistics.max_value, 99);
assert_eq!(statistics.min_value, 1);
assert_eq!(statistics.cardinality, 99);
```

--------------------------------

### Get Cardinality of Treemap

Source: https://docs.rs/croaring/2.5.2/croaring/treemap/struct.Treemap.html

Demonstrates how to get the number of elements currently stored in the Treemap using the `cardinality` method. This is a fundamental operation for understanding the size of the set.

```rust
use std::u64;
use croaring::Treemap;

let mut treemap = Treemap::new();
treemap.add(1);

assert_eq!(treemap.cardinality(), 1);

treemap.add(u64::MAX);

assert_eq!(treemap.cardinality(), 2);
```

--------------------------------

### Bitmap64 Creation Methods

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap64/struct.Bitmap64.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for initializing a new Bitmap64 instance from scratch, slices, or ranges.

```APIDOC
## [METHOD] Bitmap64::new / of / from_range

### Description
Initializes a new Bitmap64 instance. Can be created empty, from a slice of u64 values, or from a range.

### Method
Rust Constructor

### Parameters
#### Request Body
- **slice** (&[u64]) - Optional - A slice of integers to initialize the bitmap.
- **range** (RangeBounds<u64>) - Optional - A range of integers to include in the bitmap.

### Response
#### Success Response (200)
- **Bitmap64** (Object) - A new instance of the Bitmap64 structure.
```

--------------------------------

### Get Bitmap Cursor to Last Value

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap64/struct.Bitmap64View.html?search=u32+-%3E+bool

Illustrates how to get a cursor pointing to the last value in a Bitmap64 object using the `cursor_to_last` method. This is useful for reverse iteration or accessing the largest element.

```rust
use croaring::Bitmap64;

let bitmap = Bitmap64::of(&[1, 100, 101, u64::MAX]);
let mut cursor = bitmap.cursor_to_last();

assert_eq!(cursor.current(), Some(u64::MAX));
cursor.rewind();
assert_eq!(cursor.current(), Some(101));
```

--------------------------------

### Navigate Bitmap64 using Bitmap64Cursor

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap64/struct.Bitmap64Cursor.html?search=std%3A%3Avec

Demonstrates how to use Bitmap64Cursor to traverse a bitmap, check for current values, and move between elements.

```rust
use croaring::Bitmap64;

let mut bitmap = Bitmap64::of(&[1, 2, 3]);
let mut cursor = bitmap.cursor();

assert!(cursor.has_value());
assert_eq!(cursor.current(), Some(1));

assert_eq!(cursor.next(), Some(2));
assert_eq!(cursor.next(), Some(3));
assert_eq!(cursor.next(), None);

cursor.move_prev();
assert_eq!(cursor.current(), Some(3));
```

--------------------------------

### Perform Bitmap Cardinality and Range Queries

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap64/struct.Bitmap64View.html?search=std%3A%3Avec

Examples of calculating the total number of elements in a bitmap and querying the number of elements within specific ranges.

```rust
use croaring::Bitmap64;
let mut bitmap = Bitmap64::of(&[1, 3, 4, u64::MAX]);

assert_eq!(bitmap.cardinality(), 4);
assert_eq!(bitmap.range_cardinality(..2), 1);
assert_eq!(bitmap.range_cardinality(2..5), 2);
```

--------------------------------

### Get Bitmap Cursor to First Value

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap64/struct.Bitmap64View.html?search=u32+-%3E+bool

Shows how to get a cursor pointing to the first value in a Bitmap64 object using the `cursor` method. Cursors provide efficient traversal of bitmap elements.

```rust
use croaring::Bitmap64;

let bitmap = Bitmap64::of(&[1, 100, 101, u64::MAX]);
let mut cursor = bitmap.cursor();

assert_eq!(cursor.current(), Some(1));
cursor.advance();
assert_eq!(cursor.current(), Some(100));
```

--------------------------------

### Create and Initialize Bitset in Rust

Source: https://docs.rs/croaring/2.5.2/croaring/bitset/struct.Bitset.html

Demonstrates how to instantiate a new Bitset using default or specific size constructors. These constructors manage memory allocation for the underlying bit storage.

```rust
use croaring::Bitset;
let bitset = Bitset::new();
assert_eq!(bitset.capacity(), 0);

let bitset_sized = Bitset::with_size(100);
assert!(bitset_sized.capacity() >= 100);
```

--------------------------------

### Add Range of Integers to Roaring Bitmap (Rust)

Source: https://docs.rs/croaring/2.5.2/src/croaring/bitmap/imp.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Adds all integers within a specified range (inclusive start, exclusive end) to the Roaring Bitmap. If the range is invalid (e.g., start >= end), no elements are added.

```Rust
impl Bitmap {
    /// Add all values in range
    ///
    /// # Examples
    ///
    /// ```
    /// use croaring::Bitmap;
    ///
    /// let mut bitmap1 = Bitmap::new();
    /// bitmap1.add_range((1..3));
    ///
    /// assert!(!bitmap1.is_empty());
    /// assert!(bitmap1.contains(1));
    /// assert!(bitmap1.contains(2));
    /// assert!(!bitmap1.contains(3));
    ///
    /// let mut bitmap2 = Bitmap::new();
    /// bitmap2.add_range((3..1));
    /// assert!(bitmap2.is_empty());
    ///
    /// let mut bitmap3 = Bitmap::new();
    /// bitmap3.add_range((3..3));
    /// assert!(bitmap3.is_empty());
    ///
    /// ```
    #[inline]
    #[doc(alias = "roaring_bitmap_add_range")]
    pub fn add_range<R: RangeBounds<u32>>(&mut self, range: R) {
        let start = match range.start_bound() {
            Bound::Included(start) => *start,
            Bound::Excluded(start) => start.saturating_add(1),
            Bound::Unbounded => 0,
        };
        let end = match range.end_bound() {
            Bound::Included(end) => end.saturating_add(1),
            Bound::Excluded(end) => *end,
            Bound::Unbounded => u32::MAX,
        };

        if start < end {
            unsafe {
                ffi::roaring_bitmap_add_range(&mut self.bitmap, start, end);
            }
        }
    }
}
```

--------------------------------

### Create Bitmap64 instances in Rust

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap64/struct.Bitmap64.html

Demonstrates how to create new Bitmap64 instances. This includes creating an empty bitmap, creating from a slice of u64 integers, and creating from a range of u64 integers.

```Rust
use croaring::Bitmap64;

// Create a new empty bitmap
let bitmap = Bitmap64::new();
assert_eq!(bitmap.cardinality(), 0);

// Creates a new bitmap from a slice of u64 integers
let bitmap_from_slice = Bitmap64::of(&[1, 2, 3]);
assert_eq!(bitmap_from_slice.cardinality(), 3);

// Create a new bitmap containing all the values in a range
// Note: from_range is not directly shown with an example here but is a documented method.

// Create a new bitmap containing all the values in a range with a step
use std::ops::Bound;
let bitmap_with_step = Bitmap64::from_range_with_step(0..10, 3);
assert_eq!(bitmap_with_step.iter().collect::<Vec<_>>(), vec![0, 3, 6, 9]);

// Example with exclusive range and step
let bitmap_exclusive_step = Bitmap64::from_range_with_step((Bound::Excluded(10), Bound::Included(30)), 10);
assert_eq!(bitmap_exclusive_step.iter().collect::<Vec<_>>(), vec![20, 30]);
```

--------------------------------

### Set and Get Bit Values (Rust)

Source: https://docs.rs/croaring/2.5.2/croaring/bitset/struct.Bitset.html?search=

Illustrates setting individual bits to true or false using `set` and `set_to_value`. It also shows how to retrieve the boolean value of a specific bit using `get`, which returns false for out-of-bounds indices.

```Rust
use croaring::Bitset;
let mut bitset = Bitset::new();
bitset.set(1);
bitset.set(2);
bitset.set(100);
assert_eq!(bitset.iter().collect::<Vec<_>>(), vec![1, 2, 100]);

let mut bitset = Bitset::new();
bitset.set_to_value(1, true);
bitset.set_to_value(2, true);
bitset.set_to_value(100, true);
bitset.set_to_value(1, false);
assert_eq!(bitset.iter().collect::<Vec<_>>(), vec![2, 100]);

let mut bitset = Bitset::new();
bitset.set(1);
bitset.set(2);
assert!(bitset.get(1));
assert!(bitset.get(2));
assert!(!bitset.get(3));
```

--------------------------------

### Bitmap Cursor Operations in Rust

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap/struct.BitmapView.html

Explains the usage of `BitmapCursor` for navigating through a `croaring::Bitmap`. The `cursor` method provides a cursor starting at the first element, and `cursor_to_last` provides one starting at the last element. These cursors allow for efficient traversal.

```rust
use croaring::Bitmap;

// Example usage of cursor (actual cursor manipulation would be more involved)
let mut bitmap = Bitmap::new();itmap.add(4);itmap.add(3);itmap.add(2);

let mut cursor = bitmap.cursor();
assert_eq!(cursor.current(), Some(&2));

let mut cursor_last = bitmap.cursor_to_last();
assert_eq!(cursor_last.current(), Some(&4));
```

--------------------------------

### Initialize and Populate Bitmap64

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap64/struct.Bitmap64.html?search=std%3A%3Avec

Demonstrates how to create a new empty Bitmap64, create one from a slice of integers, and perform range-based initialization.

```rust
use croaring::Bitmap64;

// Create empty
let bitmap = Bitmap64::new();

// Create from slice
let bitmap_from_slice = Bitmap64::of(&[1, 2, 3]);

// Create from range with step
let bitmap_range = Bitmap64::from_range_with_step(0..10, 3);
assert_eq!(bitmap_range.iter().collect::<Vec<_>>(), vec![0, 3, 6, 9]);
```

--------------------------------

### Perform Bitmap Cardinality and Range Queries

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap64/struct.Bitmap64View.html

Examples of calculating the total number of elements in a bitmap or within a specific range using cardinality methods.

```Rust
use croaring::Bitmap64;
let mut bitmap = Bitmap64::of(&[1, 3, 4, u64::MAX]);

assert_eq!(bitmap.cardinality(), 4);
assert_eq!(bitmap.range_cardinality(2..5), 2);
assert_eq!(bitmap.range_cardinality(4..=u64::MAX), 2);
```

--------------------------------

### Add Range of Elements to Treemap (Rust)

Source: https://docs.rs/croaring/2.5.2/src/croaring/treemap/imp.rs.html

Adds all `u64` values within a specified range to the `Treemap`. Supports various range syntaxes like `start..end`, `start..=end`, and open-ended ranges. Handles empty or inverted ranges gracefully.

```rust
impl Treemap {
    /// Add all values in range
    ///
    /// # Examples
    ///
    /// ```
    /// use croaring::Treemap;
    ///
    /// let mut treemap1 = Treemap::new();
    /// treemap1.add_range((1..3));
    ///
    /// assert!(!treemap1.is_empty());
    /// assert!(treemap1.contains(1));
    /// assert!(treemap1.contains(2));
    /// assert!(!treemap1.contains(3));
    ///
    /// let mut treemap2 = Treemap::new();
    /// treemap2.add_range((3..1));
    /// assert!(treemap2.is_empty());
    ///
    /// let mut treemap3 = Treemap::new();
    /// treemap3.add_range((3..3));
    /// assert!(treemap3.is_empty());
    ///
    /// let mut treemap4 = Treemap::new();
    /// treemap4.add_range(..=2);
    /// treemap4.add_range(u64::MAX..=u64::MAX);
    /// assert!(treemap4.contains(0));
    /// assert!(treemap4.contains(1));
    /// assert!(treemap4.contains(2));
    /// assert!(treemap4.contains(u64::MAX));
    /// assert_eq!(treemap4.cardinality(), 4);
    /// ```
    pub fn add_range<R: RangeBounds<u64>>(&mut self, range: R) {
        let (start, end) = range_to_inclusive(range);
        self.add_range_inclusive(start, end);
    }

    fn add_range_inclusive(&mut self, start: u64, end: u64) {
        if start > end {
            return;
        }
        let (start_high, start_low) = util::split(start);
        let (end_high, end_low) = util::split(end);
        if start_high == end_high {
            self.map
                .entry(start_high)
                .or_default()
                .add_range(start_low..=end_low);
            return;
        }

        // Because start and end don't land on the same inner bitmap,
        // we need to do this in multiple steps:
        // 1. Partially fill the first bitmap with values from the closed
        //    interval [start_low, uint32_max]
        // 2. Fill intermediate bitmaps completely: [0, uint32_max]
        // 3. Partially fill the last bitmap with values from the closed
        //    interval [0, end_low]

        // Step 1: Partially fill the first bitmap
        {
            let bitmap = self.get_or_create(start_high);
            bitmap.add_range(start_low..=u32::MAX);
        }
        // Step 2: Fill intermediate bitmaps completely
        for i in start_high + 1..end_high {
            // This blows away the container, is it worth trying to save any existing alocations?
// ... other methods
```

--------------------------------

### Bitmap Operations Example in Rust

Source: https://docs.rs/croaring/2.5.2/src/croaring/bitmap/mod.rs.html

Demonstrates basic usage of the Bitmap struct, including adding elements, optimizing the bitmap, performing set operations (AND, OR), and checking for element containment. It also shows how to create a new bitmap from multiple existing ones using `fast_or`.

```rust
use croaring::Bitmap;

let mut rb1 = Bitmap::new();
rb1.add(1);
rb1.add(2);
rb1.add(3);
rb1.add(4);
rb1.add(5);
rb1.add(100);
rb1.add(1000);
rb1.run_optimize();

let mut rb2 = Bitmap::new();
rb2.add(3);
rb2.add(4);
rb2.add(1000);
rb2.run_optimize();

let mut rb3 = Bitmap::new();

assert_eq!(rb1.cardinality(), 7);
assert!(rb1.contains(3));

rb1.and_inplace(&rb2);
rb3.add(5);
rb3.or_inplace(&rb1);

#[cfg(feature = "alloc")]
let mut rb4 = Bitmap::fast_or(&[&rb1, &rb2, &rb3]);
#[cfg(not(feature = "alloc"))]
let mut rb4 = Bitmap::new();

rb1.and_inplace(&rb2);
println!("{:?}", rb1);

rb3.add(5);
rb3.or_inplace(&rb1);

println!("{:?}", rb1);

rb3.add(5);
rb3.or_inplace(&rb1);

#[cfg(feature = "alloc")]
println!("{:?}", rb3.to_vec());
println!("{:?}", rb3);
println!("{:?}", rb4);

#[cfg(feature = "alloc")]
{
rb4 = Bitmap::fast_or(&[&rb1, &rb2, &rb3]);
}

println!("{:?}", rb4);
```

--------------------------------

### Bitmap Creation from Range

Source: https://docs.rs/croaring/2.5.2/src/croaring/bitmap/imp.rs.html

Creates a new Bitmap instance containing all integers within a specified range. The range can be defined using standard Rust range syntax (e.g., `start..end`, `start..=end`, or tuple with `Bound`).

```APIDOC
## POST /from_range

### Description
Creates a new Bitmap instance containing all integers within a specified range. The range can be defined using standard Rust range syntax (e.g., `start..end`, `start..=end`, or tuple with `Bound`).

### Method
POST

### Endpoint
/from_range

### Parameters
#### Request Body
- **range** (RangeBounds<u32>) - Required - The range of u32 integers to include in the bitmap. Examples: `"5..10"`, `"5..=7"`, `{"from": {"excluded": 2}, "to": {"excluded": 6}}`.

### Request Example
```json
{
  "range": "5..10"
}
```

### Response
#### Success Response (200)
- **bitmap** (Bitmap) - The newly created Bitmap object containing elements within the specified range.

#### Response Example
```json
{
  "bitmap": "<bitmap_representation>"
}
```
```

--------------------------------

### GET /try_deserialize

Source: https://docs.rs/croaring/2.5.2/croaring/treemap/struct.Treemap.html?search=u32+-%3E+bool

Deserializes a byte slice into a Treemap instance.

```APIDOC
## GET /try_deserialize

### Description
Given a serialized treemap as a slice of bytes in format `S`, returns a Treemap instance. Returns None on invalid input.

### Method
GET

### Endpoint
/try_deserialize

### Parameters
#### Query Parameters
- **buffer** (bytes) - Required - The serialized byte slice.

### Response
#### Success Response (200)
- **treemap** (Treemap) - The deserialized treemap instance.
```

--------------------------------

### Create and Initialize Bitset (Rust)

Source: https://docs.rs/croaring/2.5.2/croaring/bitset/struct.Bitset.html?search=

Demonstrates creating a new, empty Bitset and a Bitset with a specified initial size. The `new()` function does not allocate memory, while `with_size()` may round up the actual capacity.

```Rust
use croaring::Bitset;
let bitset = Bitset::new();
assert_eq!(bitset.capacity(), 0);
assert_eq!(bitset.size_in_bits(), 0);

let bitset = Bitset::with_size(100);
// Actual size/capacity may be rounded up
assert!(bitset.capacity() >= 100);
assert!(bitset.size_in_bits() >= 100);
```

--------------------------------

### GET /iterator/cmp

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap/struct.BitmapIterator.html?search=std%3A%3Avec

Lexicographically compares the elements of this iterator with those of another.

```APIDOC
## GET /iterator/cmp

### Description
Lexicographically compares the elements of this iterator with those of another.

### Method
GET

### Endpoint
/iterator/cmp

### Parameters
#### Query Parameters
- **other** (IntoIterator) - Required - The iterator to compare against.

### Response
#### Success Response (200)
- **ordering** (Ordering) - The result of the comparison (Less, Equal, or Greater).
```

--------------------------------

### Bitset Initialization

Source: https://docs.rs/croaring/2.5.2/src/croaring/bitset/imp.rs.html?search=

Methods for creating new bitset instances, either empty or with a pre-allocated capacity.

```APIDOC
## POST /bitset/new

### Description
Creates a new, empty bitset instance without performing any heap allocation.

### Method
POST

### Endpoint
Bitset::new()

### Response
#### Success Response (200)
- **bitset** (Bitset) - A new instance of a Bitset with zero capacity.

---

## POST /bitset/with_size

### Description
Creates a new bitset initialized with a specific capacity in bits.

### Method
POST

### Parameters
#### Request Body
- **size** (usize) - Required - The initial capacity in bits.

### Response
#### Success Response (200)
- **bitset** (Bitset) - A new Bitset instance with at least the requested capacity.
```

--------------------------------

### GET /iterator/unzip

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap/struct.BitmapIterator.html?search=std%3A%3Avec

Converts an iterator of pairs into a pair of containers.

```APIDOC
## GET /iterator/unzip

### Description
Converts an iterator of pairs into a pair of containers.

### Method
GET

### Endpoint
/iterator/unzip

### Response
#### Success Response (200)
- **result** (Tuple) - A pair of containers containing the unzipped elements.
```

--------------------------------

### Bitset Creation and Initialization

Source: https://docs.rs/croaring/2.5.2/src/croaring/bitset/imp.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for initializing new bitsets, either empty or with a pre-allocated capacity.

```APIDOC
## POST /bitset/new

### Description
Creates a new, empty bitset without allocating memory.

### Method
POST

### Endpoint
/bitset/new

### Response
#### Success Response (200)
- **bitset** (Object) - A new instance of Bitset with zero capacity.

---

## POST /bitset/with_size

### Description
Creates a new bitset initialized with a specific capacity.

### Method
POST

### Endpoint
/bitset/with_size

### Parameters
#### Request Body
- **size** (usize) - Required - The initial capacity in bits.

### Response
#### Success Response (200)
- **bitset** (Object) - A new instance of Bitset with at least the requested capacity.
```

--------------------------------

### GET /bitset/get

Source: https://docs.rs/croaring/2.5.2/src/croaring/bitset/imp.rs.html?search=std%3A%3Avec

Retrieves the boolean value of the bit at a specific index.

```APIDOC
## GET /bitset/get

### Description
Returns the value of the bit at the given index. Returns false if the index is out of bounds.

### Method
GET

### Parameters
#### Query Parameters
- **i** (usize) - Required - The index to query.

### Response
#### Success Response (200)
- **value** (boolean) - The value of the bit.
```

--------------------------------

### croaring-2.5.2 Crate Initialization and Module Structure (Rust)

Source: https://docs.rs/croaring/2.5.2/src/croaring/lib.rs.html?search=std%3A%3Avec

This snippet shows the basic setup of the croaring-2.5.2 crate in Rust. It includes necessary feature flags for documentation and standard library usage, along with the declaration of various modules like bitmap, bitmap64, bitset, and treemap. It also re-exports key types for easier access.

```rust
#![no_std]
#![cfg_attr(docsrs, feature(doc_cfg))]
#![deny(missing_docs)]
//! Rust wrapper for `CRoaring` (a C/C++ implementation at <https://github.com/RoaringBitmap/CRoaring>)
//! 
//! Provides Compressed Bitmaps, which act like a set of integers in an efficient way.

#[cfg(feature = "alloc")]
extern crate alloc;

#[cfg(feature = "std")]
extern crate std;

pub mod bitmap;
pub mod bitmap64;
pub mod bitset;

#[cfg(feature = "alloc")]
pub mod treemap;

mod callback;
#[cfg(any(feature = "alloc", feature = "allocator-api2"))]
mod rust_alloc;
mod serialization;

mod sealed {
    pub trait Sealed {}
}

pub use serialization::*;

pub use bitmap::{Bitmap, BitmapView};
pub use bitmap64::{Bitmap64, Bitmap64View};
pub use bitset::Bitset;

#[cfg(feature = "alloc")]
pub use treemap::Treemap;

#[cfg(feature = "allocator-api2")]
pub use rust_alloc::configure_custom_alloc;
#[cfg(feature = "alloc")]
pub use rust_alloc::configure_rust_alloc;

```

--------------------------------

### Execute Subset and Extremum Operations

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap64/struct.Bitmap64View.html?search=std%3A%3Avec

Demonstrates how to check for subset relationships between bitmaps and retrieve the minimum or maximum values stored within the structure.

```rust
use croaring::Bitmap64;
let bitmap1: Bitmap64 = (5..10).collect();
let bitmap2: Bitmap64 = (5..8).collect();

assert!(bitmap2.is_subset(&bitmap1));
assert_eq!(bitmap1.minimum(), Some(5));
assert_eq!(bitmap1.maximum(), Some(9));
```

--------------------------------

### GET /intersect

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap64/struct.Bitmap64View.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Checks for common elements between two bitmaps.

```APIDOC
## GET /intersect

### Description
Determines if the current bitmap and another bitmap share any common elements.

### Method
GET

### Parameters
#### Query Parameters
- **other** (Bitmap64) - Required - The bitmap to compare against.

### Response
#### Success Response (200)
- **result** (bool) - True if there is an intersection, false otherwise.
```

--------------------------------

### Navigate Bitmap64 with Cursor in Rust

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap64/struct.Bitmap64Cursor.html

Demonstrates how to use Bitmap64Cursor to traverse a bitmap, check for values, and move between positions. It covers basic cursor movement and state validation.

```rust
use croaring::Bitmap64;
let mut bitmap = Bitmap64::of(&[1, 2, 3]);
let mut cursor = bitmap.cursor();

assert!(cursor.has_value());
assert_eq!(cursor.current(), Some(1));

cursor.move_next();
assert_eq!(cursor.current(), Some(2));

assert_eq!(cursor.next(), Some(3));
assert_eq!(cursor.next(), None);
```

--------------------------------

### GET /bitset/count

Source: https://docs.rs/croaring/2.5.2/src/croaring/bitset/imp.rs.html?search=std%3A%3Avec

Returns the total number of set bits (1s) in the bitset.

```APIDOC
## GET /bitset/count

### Description
Calculates and returns the population count of the bitset.

### Method
GET

### Response
#### Success Response (200)
- **count** (usize) - The number of bits set to 1.
```

--------------------------------

### GET /bitmap/validate

Source: https://docs.rs/croaring/2.5.2/src/croaring/bitmap/imp.rs.html?search=std%3A%3Avec

Performs an internal integrity check on the bitmap structure.

```APIDOC
## GET /bitmap/validate

### Description
Validates the internal consistency of the bitmap. Should always return valid for correctly constructed bitmaps.

### Method
GET

### Endpoint
/bitmap/validate

### Response
#### Success Response (200)
- **status** (String) - "OK"

#### Error Response (400)
- **error** (String) - Description of the validation failure
```

--------------------------------

### Bitmap Statistics in Rust

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap/struct.BitmapView.html

Demonstrates how to obtain detailed statistics about a `croaring::Bitmap` using the `statistics` method. It shows the number of containers, types of containers (array, run, bitset), values within containers, byte sizes, min/max values, and cardinality. The example also shows how statistics change after `run_optimize`.

```rust
use croaring::Bitmap;

let mut bitmap: Bitmap = (1..100).collect();
let statistics = bitmap.statistics();

assert_eq!(statistics.n_containers, 1);
assert_eq!(statistics.n_array_containers, 1);
assert_eq!(statistics.n_run_containers, 0);
assert_eq!(statistics.n_bitset_containers, 0);
assert_eq!(statistics.n_values_array_containers, 99);
assert_eq!(statistics.n_values_run_containers, 0);
assert_eq!(statistics.n_values_bitset_containers, 0);
assert_eq!(statistics.n_bytes_array_containers, 198);
assert_eq!(statistics.n_bytes_run_containers, 0);
assert_eq!(statistics.n_bytes_bitset_containers, 0);
assert_eq!(statistics.max_value, 99);
assert_eq!(statistics.min_value, 1);
assert_eq!(statistics.cardinality, 99);

bitmap.run_optimize();
let statistics = bitmap.statistics();

assert_eq!(statistics.n_containers, 1);
assert_eq!(statistics.n_array_containers, 0);
assert_eq!(statistics.n_run_containers, 1);
assert_eq!(statistics.n_bitset_containers, 0);
assert_eq!(statistics.n_values_array_containers, 0);
assert_eq!(statistics.n_values_run_containers, 99);
assert_eq!(statistics.n_values_bitset_containers, 0);
assert_eq!(statistics.n_bytes_array_containers, 0);
assert_eq!(statistics.n_bytes_run_containers, 6);
assert_eq!(statistics.n_bytes_bitset_containers, 0);
assert_eq!(statistics.max_value, 99);
assert_eq!(statistics.min_value, 1);
assert_eq!(statistics.cardinality, 99);
```

--------------------------------

### GET /cursor_to_last

Source: https://docs.rs/croaring/2.5.2/src/croaring/bitmap64/iter.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves a cursor positioned at the last value of the bitmap.

```APIDOC
## GET /cursor_to_last

### Description
Returns a Bitmap64Cursor pointing at the last value in the bitmap.

### Method
GET

### Endpoint
/cursor_to_last

### Response
#### Success Response (200)
- **cursor** (Bitmap64Cursor) - A cursor instance initialized at the last element.

### Response Example
{
  "cursor": "Bitmap64Cursor::at_last"
}
```

--------------------------------

### Bitmap64 Creation and Initialization

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap64/struct.Bitmap64.html

Methods for creating new Bitmap64 instances, including empty bitmaps, bitmaps from slices, and bitmaps from ranges.

```APIDOC
## Bitmap64

### Description
A Bitmap which can hold 64-bit integers.

### Methods

#### `new()`

**Description:** Create a new empty bitmap.

**Method:** `new()`

**Endpoint:** N/A (Constructor)

**Request Body:** None

**Response:**
  * **Success Response (200):** A new, empty `Bitmap64` instance.

**Example:**
```rust
use croaring::Bitmap64;
let bitmap = Bitmap64::new();
assert_eq!(bitmap.cardinality(), 0);
```

#### `of(slice: &[u64])`

**Description:** Creates a new bitmap from a slice of u64 integers.

**Method:** `of()`

**Endpoint:** N/A (Constructor)

**Parameters:**
  * **Path Parameters:** None
  * **Query Parameters:** None
  * **Request Body:**
    * **`slice`** (array of u64) - Required - A slice containing the u64 integers to initialize the bitmap with.

**Response:**
  * **Success Response (200):** A new `Bitmap64` instance initialized with the provided values.

**Example:**
```rust
use croaring::Bitmap64;
let bitmap = Bitmap64::of(&[1, 2, 3]);
assert_eq!(bitmap.cardinality(), 3);
```

#### `from_range<R: RangeBounds<u64>>(range: R)`

**Description:** Create a new bitmap containing all the values in a range.

**Method:** `from_range()`

**Endpoint:** N/A (Constructor)

**Parameters:**
  * **Path Parameters:** None
  * **Query Parameters:** None
  * **Request Body:**
    * **`range`** (RangeBounds<u64>) - Required - The range of u64 values to include in the bitmap.

**Response:**
  * **Success Response (200):** A new `Bitmap64` instance containing values from the specified range.

**Example:**
```rust
use std::ops::Bound;
use croaring::Bitmap64;

// Example with a simple range
let bitmap = Bitmap64::from_range(0..5);
assert_eq!(bitmap.cardinality(), 5);
assert!(bitmap.contains(0));
assert!(bitmap.contains(4));
assert!(!bitmap.contains(5));

// Example with an inclusive range
let bitmap_inclusive = Bitmap64::from_range(10..=12);
assert_eq!(bitmap_inclusive.cardinality(), 3);
assert!(bitmap_inclusive.contains(10));
assert!(bitmap_inclusive.contains(12));

// Example with an empty range
let empty_bitmap = Bitmap64::from_range(5..2);
assert!(empty_bitmap.is_empty());
```

#### `from_range_with_step<R: RangeBounds<u64>>(range: R, step: u64)`

**Description:** Create a new bitmap containing all the values in `range` which are a multiple of `step` away from the lower bound. If `step` is 0 or there are no values which are a multiple of `step` away from the lower bound within range, an empty bitmap is returned.

**Method:** `from_range_with_step()`

**Endpoint:** N/A (Constructor)

**Parameters:**
  * **Path Parameters:** None
  * **Query Parameters:** None
  * **Request Body:**
    * **`range`** (RangeBounds<u64>) - Required - The range of u64 values to consider.
    * **`step`** (u64) - Required - The step value. Values will be included if they are a multiple of `step` away from the lower bound of the range.

**Response:**
  * **Success Response (200):** A new `Bitmap64` instance containing values from the specified range with the given step.

**Example:**
```rust
use std::ops::Bound;
use croaring::Bitmap64;

let bitmap = Bitmap64::from_range_with_step(0..10, 3);
assert_eq!(bitmap.iter().collect::<Vec<_>>(), vec![0, 3, 6, 9]);

// empty ranges
assert_eq!(Bitmap64::from_range_with_step(0..0, 1), Bitmap64::new());
assert_eq!(Bitmap64::from_range_with_step(100..=0, 0), Bitmap64::new());

// step is 0
assert_eq!(Bitmap64::from_range_with_step(0..10, 0), Bitmap64::new());

// No values of step in range
let bitmap = Bitmap64::from_range_with_step((Bound::Excluded(0), Bound::Included(10)), 100);
assert_eq!(bitmap, Bitmap64::new());
let bitmap = Bitmap64::from_range_with_step((Bound::Excluded(u64::MAX), Bound::Included(u64::MAX)), 1);
assert_eq!(bitmap, Bitmap64::new());

// Exclusive ranges still step from the start, but do not include it
let bitmap = Bitmap64::from_range_with_step((Bound::Excluded(10), Bound::Included(30)), 10);
assert_eq!(bitmap.iter().collect::<Vec<_>>(), vec![20, 30]);

// Ranges including max value
let bitmap = Bitmap64::from_range_with_step((u64::MAX - 1)..=u64::MAX, 1);
assert_eq!(bitmap.iter().collect::<Vec<_>>(), vec![u64::MAX - 1, u64::MAX]);
let bitmap = Bitmap64::from_range_with_step((u64::MAX - 1)..=u64::MAX, 3);
assert_eq!(bitmap.iter().collect::<Vec<_>>(), vec![u64::MAX - 1]);
```
```

--------------------------------

### Initialize and manage Bitmap storage in Rust

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap/struct.Bitmap.html?search=u32+-%3E+bool

Demonstrates how to create a new Bitmap instance, including optional container capacity hints for performance optimization.

```rust
use croaring::Bitmap;

// Create empty bitmap
let bitmap = Bitmap::new();
assert!(bitmap.is_empty());

// Create with capacity hint
let bitmap_with_cap = Bitmap::with_container_capacity(1_000);
assert!(bitmap_with_cap.is_empty());
```

--------------------------------

### GET /cursor

Source: https://docs.rs/croaring/2.5.2/src/croaring/bitmap64/iter.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves a cursor positioned at the first value of the bitmap.

```APIDOC
## GET /cursor

### Description
Returns a Bitmap64Cursor pointing at the first value in the bitmap.

### Method
GET

### Endpoint
/cursor

### Response
#### Success Response (200)
- **cursor** (Bitmap64Cursor) - A cursor instance initialized at the first element.

### Response Example
{
  "cursor": "Bitmap64Cursor::at_first"
}
```

--------------------------------

### Get Cardinality

Source: https://docs.rs/croaring/2.5.2/croaring/bitmap64/struct.Bitmap64.html

Returns the total number of values currently stored in the bitmap.

```APIDOC
## GET /bitmap64/cardinality

### Description
Returns the total count of unique values present in the bitmap.

### Method
GET

### Endpoint
`/bitmap64/cardinality`

### Parameters
No parameters required.

### Response
#### Success Response (200)
- **cardinality** (u64) - The number of values in the bitmap.

#### Response Example
```json
{
  "cardinality": 5
}
```
```

--------------------------------

### Create Bitmap64 instances

Source: https://docs.rs/croaring/2.5.2/src/croaring/bitmap64/imp.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides methods to initialize a Bitmap64. This includes creating an empty bitmap, creating one from a slice of u64 values, and generating a bitmap from a range with a specific step.

```rust
use croaring::Bitmap64;

// Create empty
let bitmap = Bitmap64::new();

// Create from slice
let bitmap_from_slice = Bitmap64::of(&[1, 2, 3]);

// Create from range with step
let bitmap_range = Bitmap64::from_range_with_step(0..10, 3);
```

--------------------------------

### GET /bitmap/contains

Source: https://docs.rs/croaring/2.5.2/croaring/bitset/struct.BitsetIterator.html?search=u32+-%3E+bool

Checks if a specific integer element exists within the bitmap.

```APIDOC
## GET /bitmap/contains

### Description
Checks if the provided integer element is contained within the bitmap.

### Method
GET

### Endpoint
/bitmap/contains

### Parameters
#### Query Parameters
- **value** (u32) - Required - The integer to check for existence.

### Response
#### Success Response (200)
- **result** (bool) - Returns true if the element is present, false otherwise.

### Response Example
{
  "result": true
}
```

--------------------------------

### Initialize croaring crate modules and features

Source: https://docs.rs/croaring/2.5.2/src/croaring/lib.rs.html?search=

This snippet demonstrates the library entry point, configuring feature flags for standard library or allocator support and exposing core bitmap structures like Bitmap, Bitmap64, and Treemap. It utilizes conditional compilation to manage dependencies based on the enabled features.

```Rust
#![no_std]
#![cfg_attr(docsrs, feature(doc_cfg))]
#![deny(missing_docs)]

#[cfg(feature = "alloc")]
extern crate alloc;

#[cfg(feature = "std")]
extern crate std;

pub mod bitmap;
pub mod bitmap64;
pub mod bitset;

#[cfg(feature = "alloc")]
pub mod treemap;

pub use bitmap::{Bitmap, BitmapView};
pub use bitmap64::{Bitmap64, Bitmap64View};
pub use bitset::Bitset;

#[cfg(feature = "alloc")]
pub use treemap::Treemap;
```
Tokens:
Raw