Struct roaring::treemap::RoaringTreemap

pub struct RoaringTreemap { /* fields omitted */ }

A compressed bitmap with u64 values. Implemented as a BTreeMap of RoaringBitmaps.

Examples

use roaring::RoaringTreemap;

let mut rb = RoaringTreemap::new();

// insert all primes less than 10
rb.insert(2);
rb.insert(3);
rb.insert(5);
rb.insert(7);
println!("total bits set to true: {}", rb.len());

Methods

impl RoaringTreemap

fn new() -> RoaringTreemap

Creates an empty RoaringTreemap.

Examples

use roaring::RoaringTreemap;
let mut rb = RoaringTreemap::new();

fn insert(&mut self, value: u64) -> bool

Adds a value to the set. Returns true if the value was not already present in the set.

Examples

use roaring::RoaringTreemap;

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

fn remove(&mut self, value: u64) -> bool

Removes a value from the set. Returns true if the value was present in the set.

Examples

use roaring::RoaringTreemap;

let mut rb = RoaringTreemap::new();
rb.insert(3);
assert_eq!(rb.remove(3), true);
assert_eq!(rb.remove(3), false);
assert_eq!(rb.contains(3), false);

fn remove_range(&mut self, range: Range<u64>) -> u64

Removes a range of values from the set specific as [start..end). Returns the number of removed values.

Note that due to the exclusive end you can't remove the item at the last index (u64::MAX) using this function!

Examples

use roaring::RoaringTreemap;

let mut rb = RoaringTreemap::new();
rb.insert(2);
rb.insert(3);
assert_eq!(rb.remove_range(2..4), 2);

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);

fn clear(&mut self)

Clears all integers in this set.

Examples

use roaring::RoaringTreemap;

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

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);

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);

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));

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));

impl RoaringTreemap

fn iter(&self) -> Iter

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

Examples

use roaring::RoaringTreemap;
use std::iter::FromIterator;

let bitmap = RoaringTreemap::from_iter(1..3);
let mut iter = bitmap.iter();

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

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 std::iter::FromIterator;

let original = RoaringTreemap::from_iter(0..6000);
let mut bitmaps = original.bitmaps();

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

fn from_bitmaps<I: IntoIterator<Item=(u32, RoaringBitmap)>>(iterator: I) -> Self

Construct a RoaringTreemap from an iterator of partition number and RoaringBitmap pairs. The partition number is defined by the 32 most significant bits of the bit index. Note that repeated partitions, if present, will replace previously set partitions.

Examples

use roaring::RoaringTreemap;
use std::iter::FromIterator;

let original = RoaringTreemap::from_iter(0..6000);
let clone = RoaringTreemap::from_bitmaps(original.bitmaps().map(|(p, b)| (p, b.clone())));

assert_eq!(clone, original);

impl RoaringTreemap

fn union_with(&mut self, other: &RoaringTreemap)

Unions in-place with the specified other bitmap.

Examples

use roaring::RoaringTreemap;

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

rb1.union_with(&rb2);

assert_eq!(rb1, rb3);

Can also be done via the BitOr operator.

use roaring::RoaringTreemap;

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

let rb1 = rb1 | rb2;

assert_eq!(rb1, rb3);

fn intersect_with(&mut self, other: &RoaringTreemap)

Intersects in-place with the specified other bitmap.

Examples

use roaring::RoaringTreemap;

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

rb1.intersect_with(&rb2);

assert_eq!(rb1, rb3);

Can also be done via the BitAnd operator.

use roaring::RoaringTreemap;

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

let rb1 = rb1 & rb2;

assert_eq!(rb1, rb3);

fn difference_with(&mut self, other: &RoaringTreemap)

Removes all values in the specified other bitmap from self, in-place.

Examples

use roaring::RoaringTreemap;

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

rb1.difference_with(&rb2);

assert_eq!(rb1, rb3);

Can also be done via the Sub operator.

use roaring::RoaringTreemap;

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

let rb1 = rb1 - rb2;

assert_eq!(rb1, rb3);

fn symmetric_difference_with(&mut self, other: &RoaringTreemap)

Replaces this bitmap with one that is equivalent to self XOR other.

Examples

use roaring::RoaringTreemap;

let mut rb1: RoaringTreemap = (1..4).collect();
let rb2: RoaringTreemap = (3..6).collect();
let rb3: RoaringTreemap = (1..3).chain(4..6).collect();

rb1.symmetric_difference_with(&rb2);

assert_eq!(rb1, rb3);

Can also be done via the BitXor operator.

use roaring::RoaringTreemap;

let mut rb1: RoaringTreemap = (1..4).collect();
let rb2: RoaringTreemap = (3..6).collect();
let rb3: RoaringTreemap = (1..3).chain(4..6).collect();

let rb1 = rb1 ^ rb2;

assert_eq!(rb1, rb3);

impl RoaringTreemap

fn is_disjoint(&self, other: &Self) -> 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);

fn is_subset(&self, other: &Self) -> 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);

fn is_superset(&self, other: &Self) -> 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);

Trait Implementations

impl Debug for RoaringTreemap

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

Formats the value using the given formatter.

impl Default for RoaringTreemap

fn default() -> RoaringTreemap

Returns the "default value" for a type.

impl<'a> IntoIterator for &'a RoaringTreemap

type Item = u64

The type of the elements being iterated over.

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a>

Creates an iterator from a value.

impl IntoIterator for RoaringTreemap

type Item = u64

The type of the elements being iterated over.

type IntoIter = IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter

Creates an iterator from a value.

impl FromIterator<u64> for RoaringTreemap

fn from_iter<I: IntoIterator<Item=u64>>(iterator: I) -> RoaringTreemap

Creates a value from an iterator.

impl Extend<u64> for RoaringTreemap

fn extend<I: IntoIterator<Item=u64>>(&mut self, iterator: I)

Extends a collection with the contents of an iterator.

impl FromIterator<(u32, RoaringBitmap)> for RoaringTreemap

fn from_iter<I: IntoIterator<Item=(u32, RoaringBitmap)>>(iterator: I)
                                                         -> RoaringTreemap

Creates a value from an iterator.

impl BitOr<RoaringTreemap> for RoaringTreemap

type Output = RoaringTreemap

The resulting type after applying the | operator

fn bitor(self, rhs: RoaringTreemap) -> RoaringTreemap

The method for the | operator

impl<'a> BitOr<&'a RoaringTreemap> for RoaringTreemap

type Output = RoaringTreemap

The resulting type after applying the | operator

fn bitor(self, rhs: &'a RoaringTreemap) -> RoaringTreemap

The method for the | operator

impl<'a> BitOr<RoaringTreemap> for &'a RoaringTreemap

type Output = RoaringTreemap

The resulting type after applying the | operator

fn bitor(self, rhs: RoaringTreemap) -> RoaringTreemap

The method for the | operator

impl<'a, 'b> BitOr<&'a RoaringTreemap> for &'b RoaringTreemap

type Output = RoaringTreemap

The resulting type after applying the | operator

fn bitor(self, rhs: &'a RoaringTreemap) -> RoaringTreemap

The method for the | operator

impl BitOrAssign<RoaringTreemap> for RoaringTreemap

fn bitor_assign(&mut self, rhs: RoaringTreemap)

The method for the |= operator

impl<'a> BitOrAssign<&'a RoaringTreemap> for RoaringTreemap

fn bitor_assign(&mut self, rhs: &'a RoaringTreemap)

The method for the |= operator

impl BitAnd<RoaringTreemap> for RoaringTreemap

type Output = RoaringTreemap

The resulting type after applying the & operator

fn bitand(self, rhs: RoaringTreemap) -> RoaringTreemap

The method for the & operator

impl<'a> BitAnd<&'a RoaringTreemap> for RoaringTreemap

type Output = RoaringTreemap

The resulting type after applying the & operator

fn bitand(self, rhs: &'a RoaringTreemap) -> RoaringTreemap

The method for the & operator

impl<'a> BitAnd<RoaringTreemap> for &'a RoaringTreemap

type Output = RoaringTreemap

The resulting type after applying the & operator

fn bitand(self, rhs: RoaringTreemap) -> RoaringTreemap

The method for the & operator

impl<'a, 'b> BitAnd<&'a RoaringTreemap> for &'b RoaringTreemap

type Output = RoaringTreemap

The resulting type after applying the & operator

fn bitand(self, rhs: &'a RoaringTreemap) -> RoaringTreemap

The method for the & operator

impl BitAndAssign<RoaringTreemap> for RoaringTreemap

fn bitand_assign(&mut self, rhs: RoaringTreemap)

The method for the &= operator

impl<'a> BitAndAssign<&'a RoaringTreemap> for RoaringTreemap

fn bitand_assign(&mut self, rhs: &'a RoaringTreemap)

The method for the &= operator

impl Sub<RoaringTreemap> for RoaringTreemap

type Output = RoaringTreemap

The resulting type after applying the - operator

fn sub(self, rhs: RoaringTreemap) -> RoaringTreemap

The method for the - operator

impl<'a> Sub<&'a RoaringTreemap> for RoaringTreemap

type Output = RoaringTreemap

The resulting type after applying the - operator

fn sub(self, rhs: &'a RoaringTreemap) -> RoaringTreemap

The method for the - operator

impl<'a> Sub<RoaringTreemap> for &'a RoaringTreemap

type Output = RoaringTreemap

The resulting type after applying the - operator

fn sub(self, rhs: RoaringTreemap) -> RoaringTreemap

The method for the - operator

impl<'a, 'b> Sub<&'a RoaringTreemap> for &'b RoaringTreemap

type Output = RoaringTreemap

The resulting type after applying the - operator

fn sub(self, rhs: &'a RoaringTreemap) -> RoaringTreemap

The method for the - operator

impl SubAssign<RoaringTreemap> for RoaringTreemap

fn sub_assign(&mut self, rhs: RoaringTreemap)

The method for the -= operator

impl<'a> SubAssign<&'a RoaringTreemap> for RoaringTreemap

fn sub_assign(&mut self, rhs: &'a RoaringTreemap)

The method for the -= operator

impl BitXor<RoaringTreemap> for RoaringTreemap

type Output = RoaringTreemap

The resulting type after applying the ^ operator

fn bitxor(self, rhs: RoaringTreemap) -> RoaringTreemap

The method for the ^ operator

impl<'a> BitXor<&'a RoaringTreemap> for RoaringTreemap

type Output = RoaringTreemap

The resulting type after applying the ^ operator

fn bitxor(self, rhs: &'a RoaringTreemap) -> RoaringTreemap

The method for the ^ operator

impl<'a> BitXor<RoaringTreemap> for &'a RoaringTreemap

type Output = RoaringTreemap

The resulting type after applying the ^ operator

fn bitxor(self, rhs: RoaringTreemap) -> RoaringTreemap

The method for the ^ operator

impl<'a, 'b> BitXor<&'a RoaringTreemap> for &'b RoaringTreemap

type Output = RoaringTreemap

The resulting type after applying the ^ operator

fn bitxor(self, rhs: &'a RoaringTreemap) -> RoaringTreemap

The method for the ^ operator

impl BitXorAssign<RoaringTreemap> for RoaringTreemap

fn bitxor_assign(&mut self, rhs: RoaringTreemap)

The method for the ^= operator

impl<'a> BitXorAssign<&'a RoaringTreemap> for RoaringTreemap

fn bitxor_assign(&mut self, rhs: &'a RoaringTreemap)

The method for the ^= operator

impl PartialEq for RoaringTreemap

fn eq(&self, __arg_0: &RoaringTreemap) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &RoaringTreemap) -> bool

This method tests for !=.

impl Clone for RoaringTreemap

fn clone(&self) -> RoaringTreemap

Returns a copy of the value.

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

Performs copy-assignment from source.