Struct IntegerList

pub struct IntegerList(pub RoaringTreemap);

A data structure that uses Roaring Bitmaps to efficiently store a list of integers.

This structure provides excellent compression while allowing direct access to individual elements without the need for full decompression.

Key features:

• Efficient compression: the underlying Roaring Bitmaps significantly reduce memory usage.
• Direct access: elements can be accessed or queried without needing to decode the entire list.
• [RoaringTreemap] backing: internally backed by [RoaringTreemap], which supports 64-bit integers.

Tuple Fields

0: RoaringTreemap

Implementations

impl IntegerList

pub fn empty() -> Self

Creates a new empty IntegerList.

pub fn new( list: impl IntoIterator<Item = u64>, ) -> Result<Self, IntegerListError>

Creates an IntegerList from a list of integers.

Returns an error if the list is not pre-sorted.

pub fn new_pre_sorted(list: impl IntoIterator<Item = u64>) -> Self

Creates an IntegerList from a pre-sorted list of integers.

Panics

Panics if the list is not pre-sorted.

pub fn append( &mut self, list: impl IntoIterator<Item = u64>, ) -> Result<u64, IntegerListError>

Appends a list of integers to the current list.

pub fn push(&mut self, value: u64) -> Result<(), IntegerListError>

Pushes a new integer to the list.

pub fn clear(&mut self)

Clears the list.

pub fn to_bytes(&self) -> Vec<u8>

Serializes a IntegerList into a sequence of bytes.

pub fn to_mut_bytes<B: BufMut>(&self, buf: &mut B)

Serializes a IntegerList into a sequence of bytes.

pub fn from_bytes(data: &[u8]) -> Result<Self, IntegerListError>

Deserializes a sequence of bytes into a proper IntegerList.

Methods from Deref<Target = RoaringTreemap>

pub fn is_disjoint(&self, other: &RoaringTreemap) -> bool

Returns true if the set has no elements in common with other. This is equivalent to checking for an empty intersection.

Examples

use roaring::RoaringTreemap;

let mut rb1 = RoaringTreemap::new();
let mut rb2 = RoaringTreemap::new();

rb1.insert(1);

assert_eq!(rb1.is_disjoint(&rb2), true);

rb2.insert(1);

assert_eq!(rb1.is_disjoint(&rb2), false);

pub fn is_subset(&self, other: &RoaringTreemap) -> bool

Returns true if this set is a subset of other.

Examples

use roaring::RoaringTreemap;

let mut rb1 = RoaringTreemap::new();
let mut rb2 = RoaringTreemap::new();

rb1.insert(1);

assert_eq!(rb1.is_subset(&rb2), false);

rb2.insert(1);

assert_eq!(rb1.is_subset(&rb2), true);

rb1.insert(2);

assert_eq!(rb1.is_subset(&rb2), false);

pub fn is_superset(&self, other: &RoaringTreemap) -> bool

Returns true if this set is a superset of other.

Examples

use roaring::RoaringTreemap;

let mut rb1 = RoaringTreemap::new();
let mut rb2 = RoaringTreemap::new();

rb1.insert(1);

assert_eq!(rb2.is_superset(&rb1), false);

rb2.insert(1);

assert_eq!(rb2.is_superset(&rb1), true);

rb1.insert(2);

assert_eq!(rb2.is_superset(&rb1), false);

pub fn contains(&self, value: u64) -> bool

Returns true if this set contains the specified integer.

Examples

use roaring::RoaringTreemap;

let mut rb = RoaringTreemap::new();
rb.insert(1);
assert_eq!(rb.contains(0), false);
assert_eq!(rb.contains(1), true);
assert_eq!(rb.contains(100), false);

pub fn is_empty(&self) -> bool

Returns true if there are no integers in this set.

Examples

use roaring::RoaringTreemap;

let mut rb = RoaringTreemap::new();
assert_eq!(rb.is_empty(), true);

rb.insert(3);
assert_eq!(rb.is_empty(), false);

pub fn is_full(&self) -> bool

Returns true if there are every possible integers in this set.

Examples

use roaring::RoaringTreemap;

let mut rb = RoaringTreemap::full();
assert!(!rb.is_empty());
assert!(rb.is_full());

pub fn len(&self) -> u64

Returns the number of distinct integers added to the set.

Examples

use roaring::RoaringTreemap;

let mut rb = RoaringTreemap::new();
assert_eq!(rb.len(), 0);

rb.insert(3);
assert_eq!(rb.len(), 1);

rb.insert(3);
rb.insert(4);
assert_eq!(rb.len(), 2);

pub fn min(&self) -> Option<u64>

Returns the minimum value in the set (if the set is non-empty).

Examples

use roaring::RoaringTreemap;

let mut rb = RoaringTreemap::new();
assert_eq!(rb.min(), None);

rb.insert(3);
rb.insert(4);
assert_eq!(rb.min(), Some(3));

pub fn max(&self) -> Option<u64>

Returns the maximum value in the set (if the set is non-empty).

Examples

use roaring::RoaringTreemap;

let mut rb = RoaringTreemap::new();
assert_eq!(rb.max(), None);

rb.insert(3);
rb.insert(4);
assert_eq!(rb.max(), Some(4));

pub fn rank(&self, value: u64) -> u64

Returns the number of integers that are <= value. rank(u64::MAX) == len()

Examples

use roaring::RoaringTreemap;

let mut rb = RoaringTreemap::new();
assert_eq!(rb.rank(0), 0);

rb.insert(3);
rb.insert(4);
assert_eq!(rb.rank(3), 1);
assert_eq!(rb.rank(10), 2)

pub fn select(&self, n: u64) -> Option<u64>

Returns the nth integer in the set or None if n >= len()

Examples

use roaring::RoaringTreemap;

let mut rb = RoaringTreemap::new();
assert_eq!(rb.select(0), None);

rb.append(vec![0, 10, 100]);

assert_eq!(rb.select(0), Some(0));
assert_eq!(rb.select(1), Some(10));
assert_eq!(rb.select(2), Some(100));
assert_eq!(rb.select(3), None);

pub fn iter(&self) -> Iter<'_>

Iterator over each value stored in the RoaringTreemap, guarantees values are ordered by value.

Examples

use roaring::RoaringTreemap;
use core::iter::FromIterator;

let bitmap = (1..3).collect::<RoaringTreemap>();
let mut iter = bitmap.iter();

assert_eq!(iter.next(), Some(1));
assert_eq!(iter.next(), Some(2));
assert_eq!(iter.next(), None);

pub fn bitmaps(&self) -> BitmapIter<'_>

Iterator over pairs of partition number and the corresponding RoaringBitmap. The partition number is defined by the 32 most significant bits of the bit index.

Examples

use roaring::{RoaringBitmap, RoaringTreemap};
use core::iter::FromIterator;

let original = (0..6000).collect::<RoaringTreemap>();
let mut bitmaps = original.bitmaps();

assert_eq!(bitmaps.next(), Some((0, &(0..6000).collect::<RoaringBitmap>())));
assert_eq!(bitmaps.next(), None);

pub fn union_len(&self, other: &RoaringTreemap) -> u64

Computes the len of the union with the specified other treemap without creating a new treemap.

This is faster and more space efficient when you’re only interested in the cardinality of the union.

Examples

use roaring::RoaringTreemap;

let rb1: RoaringTreemap = (1..4).collect();
let rb2: RoaringTreemap = (3..5).collect();


assert_eq!(rb1.union_len(&rb2), (rb1 | rb2).len());

pub fn intersection_len(&self, other: &RoaringTreemap) -> u64

Computes the len of the intersection with the specified other treemap without creating a new treemap.

This is faster and more space efficient when you’re only interested in the cardinality of the intersection.

Examples

use roaring::RoaringTreemap;

let rb1: RoaringTreemap = (1..4).collect();
let rb2: RoaringTreemap = (3..5).collect();


assert_eq!(rb1.intersection_len(&rb2), (rb1 & rb2).len());

pub fn difference_len(&self, other: &RoaringTreemap) -> u64

Computes the len of the difference with the specified other treemap without creating a new treemap.

This is faster and more space efficient when you’re only interested in the cardinality of the difference.

Examples

use roaring::RoaringTreemap;

let rb1: RoaringTreemap = (1..4).collect();
let rb2: RoaringTreemap = (3..5).collect();


assert_eq!(rb1.difference_len(&rb2), (rb1 - rb2).len());

pub fn symmetric_difference_len(&self, other: &RoaringTreemap) -> u64

Computes the len of the symmetric difference with the specified other treemap without creating a new bitmap.

This is faster and more space efficient when you’re only interested in the cardinality of the symmetric difference.

Examples

use roaring::RoaringTreemap;

let rb1: RoaringTreemap = (1..4).collect();
let rb2: RoaringTreemap = (3..5).collect();


assert_eq!(rb1.symmetric_difference_len(&rb2), (rb1 ^ rb2).len());

pub fn serialized_size(&self) -> usize

Return the size in bytes of the serialized output. This is compatible with the official C/C++, Java and Go implementations.

Examples

use roaring::RoaringTreemap;

let rb1: RoaringTreemap = (1..4).collect();
let mut bytes = Vec::with_capacity(rb1.serialized_size());
rb1.serialize_into(&mut bytes).unwrap();
let rb2 = RoaringTreemap::deserialize_from(&bytes[..]).unwrap();

assert_eq!(rb1, rb2);

pub fn serialize_into<W>(&self, writer: W) -> Result<(), Error>

where W: Write,

Serialize this bitmap. This is compatible with the official C/C++, Java and Go implementations.

Examples

use roaring::RoaringTreemap;

let rb1: RoaringTreemap = (1..4).collect();
let mut bytes = vec![];
rb1.serialize_into(&mut bytes).unwrap();
let rb2 = RoaringTreemap::deserialize_from(&bytes[..]).unwrap();

assert_eq!(rb1, rb2);

Trait Implementations

impl<'a> Arbitrary<'a> for IntegerList

Available on crate feature arbitrary only.

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl Clone for IntegerList

fn clone(&self) -> IntegerList

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for IntegerList

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for IntegerList

fn default() -> IntegerList

Returns the “default value” for a type.

impl Deref for IntegerList

type Target = RoaringTreemap

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'de> Deserialize<'de> for IntegerList

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for IntegerList

fn eq(&self, other: &IntegerList) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for IntegerList

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for IntegerList

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 24 bytes