[−][src]Struct roaring::treemap::RoaringTreemap
A compressed bitmap with u64 values.
Implemented as a BTreeMap
of RoaringBitmap
s.
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
[src]
pub fn new() -> RoaringTreemap
[src]
Creates an empty RoaringTreemap
.
Examples
use roaring::RoaringTreemap; let mut rb = RoaringTreemap::new();
pub fn insert(&mut self, value: u64) -> bool
[src]
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);
pub fn remove(&mut self, value: u64) -> bool
[src]
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);
pub fn remove_range(&mut self, range: Range<u64>) -> u64
[src]
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);
pub fn contains(&self, value: u64) -> bool
[src]
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 clear(&mut self)
[src]
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);
pub fn is_empty(&self) -> bool
[src]
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 len(&self) -> u64
[src]
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>
[src]
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>
[src]
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
[src]
ⓘImportant traits for Iter<'a>pub fn iter(&self) -> Iter
[src]
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);
pub fn bitmaps(&self) -> BitmapIter
[src]
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);
pub fn from_bitmaps<I: IntoIterator<Item = (u32, RoaringBitmap)>>(
iterator: I
) -> Self
[src]
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
[src]
pub fn union_with(&mut self, other: &RoaringTreemap)
[src]
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);
pub fn intersect_with(&mut self, other: &RoaringTreemap)
[src]
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);
pub fn difference_with(&mut self, other: &RoaringTreemap)
[src]
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);
pub fn symmetric_difference_with(&mut self, other: &RoaringTreemap)
[src]
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
[src]
pub fn is_disjoint(&self, other: &Self) -> bool
[src]
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: &Self) -> bool
[src]
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: &Self) -> bool
[src]
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 Extend<u64> for RoaringTreemap
[src]
fn extend<I: IntoIterator<Item = u64>>(&mut self, iterator: I)
[src]
impl Default for RoaringTreemap
[src]
fn default() -> RoaringTreemap
[src]
impl<'a> IntoIterator for &'a RoaringTreemap
[src]
type Item = u64
The type of the elements being iterated over.
type IntoIter = Iter<'a>
Which kind of iterator are we turning this into?
ⓘImportant traits for Iter<'a>fn into_iter(self) -> Iter<'a>
[src]
impl IntoIterator for RoaringTreemap
[src]
type Item = u64
The type of the elements being iterated over.
type IntoIter = IntoIter
Which kind of iterator are we turning this into?
ⓘImportant traits for IntoIterfn into_iter(self) -> IntoIter
[src]
impl Clone for RoaringTreemap
[src]
fn clone(&self) -> RoaringTreemap
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl PartialEq<RoaringTreemap> for RoaringTreemap
[src]
fn eq(&self, other: &RoaringTreemap) -> bool
[src]
fn ne(&self, other: &RoaringTreemap) -> bool
[src]
impl Debug for RoaringTreemap
[src]
impl Sub<RoaringTreemap> for RoaringTreemap
[src]
type Output = RoaringTreemap
The resulting type after applying the -
operator.
fn sub(self, rhs: RoaringTreemap) -> RoaringTreemap
[src]
impl<'a> Sub<&'a RoaringTreemap> for RoaringTreemap
[src]
type Output = RoaringTreemap
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a RoaringTreemap) -> RoaringTreemap
[src]
impl<'a> Sub<RoaringTreemap> for &'a RoaringTreemap
[src]
type Output = RoaringTreemap
The resulting type after applying the -
operator.
fn sub(self, rhs: RoaringTreemap) -> RoaringTreemap
[src]
impl<'a, 'b> Sub<&'a RoaringTreemap> for &'b RoaringTreemap
[src]
type Output = RoaringTreemap
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a RoaringTreemap) -> RoaringTreemap
[src]
impl SubAssign<RoaringTreemap> for RoaringTreemap
[src]
fn sub_assign(&mut self, rhs: RoaringTreemap)
[src]
impl<'a> SubAssign<&'a RoaringTreemap> for RoaringTreemap
[src]
fn sub_assign(&mut self, rhs: &'a RoaringTreemap)
[src]
impl BitAnd<RoaringTreemap> for RoaringTreemap
[src]
type Output = RoaringTreemap
The resulting type after applying the &
operator.
fn bitand(self, rhs: RoaringTreemap) -> RoaringTreemap
[src]
impl<'a> BitAnd<&'a RoaringTreemap> for RoaringTreemap
[src]
type Output = RoaringTreemap
The resulting type after applying the &
operator.
fn bitand(self, rhs: &'a RoaringTreemap) -> RoaringTreemap
[src]
impl<'a> BitAnd<RoaringTreemap> for &'a RoaringTreemap
[src]
type Output = RoaringTreemap
The resulting type after applying the &
operator.
fn bitand(self, rhs: RoaringTreemap) -> RoaringTreemap
[src]
impl<'a, 'b> BitAnd<&'a RoaringTreemap> for &'b RoaringTreemap
[src]
type Output = RoaringTreemap
The resulting type after applying the &
operator.
fn bitand(self, rhs: &'a RoaringTreemap) -> RoaringTreemap
[src]
impl BitOr<RoaringTreemap> for RoaringTreemap
[src]
type Output = RoaringTreemap
The resulting type after applying the |
operator.
fn bitor(self, rhs: RoaringTreemap) -> RoaringTreemap
[src]
impl<'a> BitOr<&'a RoaringTreemap> for RoaringTreemap
[src]
type Output = RoaringTreemap
The resulting type after applying the |
operator.
fn bitor(self, rhs: &'a RoaringTreemap) -> RoaringTreemap
[src]
impl<'a> BitOr<RoaringTreemap> for &'a RoaringTreemap
[src]
type Output = RoaringTreemap
The resulting type after applying the |
operator.
fn bitor(self, rhs: RoaringTreemap) -> RoaringTreemap
[src]
impl<'a, 'b> BitOr<&'a RoaringTreemap> for &'b RoaringTreemap
[src]
type Output = RoaringTreemap
The resulting type after applying the |
operator.
fn bitor(self, rhs: &'a RoaringTreemap) -> RoaringTreemap
[src]
impl BitXor<RoaringTreemap> for RoaringTreemap
[src]
type Output = RoaringTreemap
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: RoaringTreemap) -> RoaringTreemap
[src]
impl<'a> BitXor<&'a RoaringTreemap> for RoaringTreemap
[src]
type Output = RoaringTreemap
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: &'a RoaringTreemap) -> RoaringTreemap
[src]
impl<'a> BitXor<RoaringTreemap> for &'a RoaringTreemap
[src]
type Output = RoaringTreemap
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: RoaringTreemap) -> RoaringTreemap
[src]
impl<'a, 'b> BitXor<&'a RoaringTreemap> for &'b RoaringTreemap
[src]
type Output = RoaringTreemap
The resulting type after applying the ^
operator.
fn bitxor(self, rhs: &'a RoaringTreemap) -> RoaringTreemap
[src]
impl BitAndAssign<RoaringTreemap> for RoaringTreemap
[src]
fn bitand_assign(&mut self, rhs: RoaringTreemap)
[src]
impl<'a> BitAndAssign<&'a RoaringTreemap> for RoaringTreemap
[src]
fn bitand_assign(&mut self, rhs: &'a RoaringTreemap)
[src]
impl BitOrAssign<RoaringTreemap> for RoaringTreemap
[src]
fn bitor_assign(&mut self, rhs: RoaringTreemap)
[src]
impl<'a> BitOrAssign<&'a RoaringTreemap> for RoaringTreemap
[src]
fn bitor_assign(&mut self, rhs: &'a RoaringTreemap)
[src]
impl BitXorAssign<RoaringTreemap> for RoaringTreemap
[src]
fn bitxor_assign(&mut self, rhs: RoaringTreemap)
[src]
impl<'a> BitXorAssign<&'a RoaringTreemap> for RoaringTreemap
[src]
fn bitxor_assign(&mut self, rhs: &'a RoaringTreemap)
[src]
impl FromIterator<u64> for RoaringTreemap
[src]
fn from_iter<I: IntoIterator<Item = u64>>(iterator: I) -> RoaringTreemap
[src]
impl FromIterator<(u32, RoaringBitmap)> for RoaringTreemap
[src]
fn from_iter<I: IntoIterator<Item = (u32, RoaringBitmap)>>(
iterator: I
) -> RoaringTreemap
[src]
iterator: I
) -> RoaringTreemap
Auto Trait Implementations
impl Unpin for RoaringTreemap
impl Send for RoaringTreemap
impl Sync for RoaringTreemap
impl RefUnwindSafe for RoaringTreemap
impl UnwindSafe for RoaringTreemap
Blanket Implementations
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<I> IntoIterator for I where
I: Iterator,
[src]
I: Iterator,
type Item = <I as Iterator>::Item
The type of the elements being iterated over.
type IntoIter = I
Which kind of iterator are we turning this into?
fn into_iter(self) -> I
[src]
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,