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

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 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.