Struct croaring::treemap::Treemap

pub struct Treemap {
    pub map: BTreeMap<u32, Bitmap>,
}

A RoaringBitmap-based structure that supports 64bit unsigned integer values

Implemented as a BTreeMap of Bitmaps.

Fields

map: BTreeMap<u32, Bitmap>

The underlying map of bitmaps

Implementations

impl Treemap

pub fn new() -> Self

Creates an empty Treemap.

Examples

use croaring::Treemap;
let treemap = Treemap::new();

pub fn from_bitmap(bitmap: Bitmap) -> Self

Creates a Treemap with the contents of a Bitmap.

Examples

use croaring::Treemap;
use croaring::Bitmap;

let bitmap = Bitmap::of(&[1, 2, 3]);
let treemap = Treemap::from_bitmap(bitmap);
assert_eq!(treemap.cardinality(), 3);

pub fn add(&mut self, value: u64)

Add the integer element to the bitmap

Examples

use std::u32;
use croaring::Treemap;

let mut treemap = Treemap::new();
treemap.add(3);
assert!(treemap.contains(3));
treemap.add(u32::MAX as u64);
assert!(treemap.contains(u32::MAX as u64));
treemap.add(u64::from(u32::MAX) + 1);
assert!(treemap.contains(u64::from(u32::MAX)+ 1));

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

Add the integer element to the bitmap. Returns true if the value was added, false if the value was already in the bitmap.

Examples

use croaring::Treemap;

let mut bitmap = Treemap::new();
assert!(bitmap.add_checked(1));
assert!(!bitmap.add_checked(1));

pub fn add_range<R: RangeBounds<u64>>(&mut self, range: R)

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 contains(&self, value: u64) -> bool

use croaring::Treemap;

let mut treemap = Treemap::new();

pub fn is_empty(&self) -> bool

Returns true if the Treemap is empty.

Examples

use std::u64;
use croaring::Treemap;

let mut treemap = Treemap::new();

assert!(treemap.is_empty());

treemap.add(u64::MAX);

assert!(!treemap.is_empty());

pub fn is_full(&self) -> bool

Returns true if the Treemap is full.

Examples

use croaring::Treemap;

let mut treemap = Treemap::new();
assert!(!treemap.is_full());

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

Return true if all the elements of Self are in &other.

Examples

use croaring::Treemap;

let bitmap1: Treemap = (5..10).collect();
let bitmap2: Treemap = (5..8).collect();
let bitmap3: Treemap = (5..10).collect();
let bitmap4: Treemap = (9..11).collect();

assert!(bitmap2.is_subset(&bitmap1));
assert!(bitmap3.is_subset(&bitmap1));
assert!(!bitmap4.is_subset(&bitmap1));

pub fn is_strict_subset(&self, other: &Treemap) -> bool

Returns true if this bitmap is a strict subset of other

pub fn flip<R: RangeBounds<u64>>(&mut self, range: R)

Negate the bits in the given range, any bit set in the range is cleared, and any bit cleared

Areas outside the interval are unchanged

Examples

use croaring::Treemap;

let mut treemap = Treemap::new();
treemap.add_range(1..5);
treemap.flip(2..10);
assert_eq!(treemap.cardinality(), 6);
assert_eq!(treemap.iter().collect::<Vec<_>>(), vec![1, 5, 6, 7, 8, 9]);

pub fn clear(&mut self)

Empties the Treemap

Examples

use std::u64;
use croaring::Treemap;

let mut treemap = Treemap::new();

treemap.add(1);
treemap.add(u64::MAX);

assert!(!treemap.is_empty());

treemap.clear();

assert!(treemap.is_empty());

pub fn remove(&mut self, element: u64)

Remove element from the Treemap

Examples

use std::u64;
use croaring::Treemap;

let mut treemap = Treemap::new();
treemap.add(u64::MAX);
treemap.remove(u64::MAX);

assert!(treemap.is_empty());

pub fn remove_checked(&mut self, element: u64) -> bool

Remove element from the Treemap, returning if a value was removed

Returns true if the element was removed, false if it was not present

Examples

use croaring::Treemap;

let mut treemap = Treemap::new();
treemap.add(u64::MAX);
assert!(treemap.remove_checked(u64::MAX));
assert!(!treemap.remove_checked(u64::MAX));

pub fn remove_range<R: RangeBounds<u64>>(&mut self, range: R)

Remove all values in range

Examples

use croaring::Treemap;

let mut treemap = Treemap::new();
treemap.add_range(0..=10);
treemap.remove_range(5..=15);
assert_eq!(treemap.cardinality(), 5);

pub fn shrink_to_fit(&mut self)

Reallocate memory to shrink the memory usage

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

Selects the value at index rank in the bitmap

The smallest value is at index 0. If ‘rank’ < cardinality(), returns Some, otherwise, returns None

Examples

use croaring::Treemap;

let mut treemap = Treemap::new();
treemap.add_range(10..=20);
assert_eq!(treemap.select(0), Some(10));
assert_eq!(treemap.select(10), Some(20));
assert_eq!(treemap.select(11), None);

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

Returns the number of elements that are smaller or equal to value

pub fn position(&self, value: u64) -> Option<u64>

Returns the index of value in the set (zero based index)

If the set doesn’t contain value, return None

The difference with the rank method is that this method will return None if the value is not in the set, whereas rank will always return a value

pub fn cardinality(&self) -> u64

Returns the number of elements contained in the Treemap

Examples

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

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

Returns the smallest value in the set. Returns u64::MAX if the set is empty.

Examples

use croaring::Treemap;

let mut treemap: Treemap = Treemap::new();
let empty_treemap: Treemap = Treemap::new();

treemap.add(120);
treemap.add(1000);

assert_eq!(treemap.minimum(), Some(120));
assert_eq!(empty_treemap.minimum(), None);

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

Returns the greatest value in the set. Returns 0 if the set is empty.

Examples

use croaring::Treemap;

let mut treemap: Treemap = Treemap::new();
let empty_treemap: Treemap = Treemap::new();

treemap.add(120);
treemap.add(1000);

assert_eq!(treemap.maximum(), Some(1000));
assert_eq!(empty_treemap.maximum(), None);

pub fn and(&self, other: &Self) -> Self

And computes the intersection between two treemaps and returns the result as a new treemap

Examples

use std::u64;
use croaring::Treemap;

let mut treemap1 = Treemap::new();
treemap1.add(u64::MAX);

let mut treemap2 = Treemap::new();
treemap2.add(u64::MAX);
treemap2.add(2);

let treemap3 = treemap1.and(&treemap2);

assert!(treemap3.contains(u64::MAX));
assert!(!treemap3.contains(2));

pub fn and_inplace(&mut self, other: &Self)

Computes the intersection between two treemaps and stores the result in the current treemap

Examples

use std::u64;
use croaring::Treemap;

let mut treemap1 = Treemap::new();
treemap1.add(u64::MAX);

let mut treemap2 = Treemap::new();
treemap2.add(25);

let mut treemap3 = Treemap::new();
treemap3.add(u64::MAX);

let mut treemap4 = Treemap::new();
treemap4.add(u64::MAX);
treemap4.add(25);

treemap1.and_inplace(&treemap2);

assert_eq!(treemap1.cardinality(), 0);
assert!(!treemap1.contains(u64::MAX));
assert!(!treemap1.contains(25));

treemap3.and_inplace(&treemap4);

assert_eq!(treemap3.cardinality(), 1);
assert!(treemap3.contains(u64::MAX));
assert!(!treemap3.contains(25));

let mut treemap5 = Treemap::new();
treemap5.add(u64::MAX);
treemap5.and_inplace(&Treemap::new());
assert_eq!(treemap5.cardinality(), 0);

pub fn or(&self, other: &Self) -> Self

Or computes the union between two bitmaps and returns the result as a new bitmap

Examples

use std::u64;
use croaring::Treemap;

let mut treemap1 = Treemap::new();
treemap1.add(u64::MAX);

let mut treemap2 = Treemap::new();
treemap2.add(25);

let treemap3 = treemap1.or(&treemap2);

assert!(treemap3.cardinality() == 2);
assert!(treemap3.contains(u64::MAX));
assert!(treemap3.contains(25));

pub fn or_inplace(&mut self, other: &Self)

Computes the intersection between two bitmaps and stores the result in the current bitmap

Examples

use croaring::Treemap;

let mut treemap1 = Treemap::new();
treemap1.add(15);

let mut treemap2 = Treemap::new();
treemap2.add(25);

let mut treemap3 = Treemap::new();
treemap3.add(15);

let mut bitmap4 = Treemap::new();
bitmap4.add(15);
bitmap4.add(25);

treemap1.and_inplace(&treemap2);

assert_eq!(treemap1.cardinality(), 0);
assert!(!treemap1.contains(15));
assert!(!treemap1.contains(25));

treemap3.and_inplace(&bitmap4);

assert_eq!(treemap3.cardinality(), 1);
assert!(treemap3.contains(15));
assert!(!treemap3.contains(25));

pub fn xor(&self, other: &Self) -> Self

Computes the symmetric difference (xor) between two treemaps and returns a new treemap.

Examples

use std::u64;
use croaring::Treemap;

let mut treemap1 = Treemap::new();
treemap1.add(15);
treemap1.add(u64::MAX);

let mut treemap2 = Treemap::new();
treemap2.add(u64::MAX);
treemap2.add(35);

let treemap3 = treemap1.xor(&treemap2);

assert_eq!(treemap3.cardinality(), 2);
assert!(treemap3.contains(15));
assert!(!treemap3.contains(25));
assert!(treemap3.contains(35));

pub fn xor_inplace(&mut self, other: &Self)

Inplace version of xor, stores result in the current treemap.

Examples

use std::u64;
use croaring::Treemap;

let mut treemap1 = Treemap::new();
treemap1.add(15);
treemap1.add(25);

let mut treemap2 = Treemap::new();
treemap2.add(25);
treemap2.add(35);

treemap1.xor_inplace(&treemap2);

assert_eq!(treemap1.cardinality(), 2);
assert!(treemap1.contains(15));
assert!(treemap1.contains(35));

let mut treemap3 = Treemap::new();
treemap3.add(15);
treemap3.xor_inplace(&Treemap::new());
assert_eq!(treemap3.cardinality(), 1);
assert!(treemap3.contains(15));

pub fn andnot(&self, other: &Self) -> Self

Computes the difference between two bitmaps and returns the result.

Examples

use std::u64;
use croaring::Treemap;

let mut treemap1 = Treemap::new();

treemap1.add(15);
treemap1.add(u64::MAX);

let mut treemap2 = Treemap::new();

treemap2.add(u64::MAX);
treemap2.add(35);

let treemap3 = treemap1.andnot(&treemap2);

assert_eq!(treemap3.cardinality(), 1);
assert!(treemap3.contains(15));
assert!(!treemap3.contains(u64::MAX));
assert!(!treemap3.contains(35));

pub fn andnot_inplace(&mut self, other: &Self)

Computes the difference between two treemaps and stores the result in the current treemap.

Examples

use std::u32;
use std::u64;
use croaring::Treemap;

let mut treemap1 = Treemap::new();

treemap1.add(15);
treemap1.add(25);
treemap1.add(u64::MAX - 10);

let mut treemap2 = Treemap::new();

treemap2.add(25);
treemap2.add(35);

treemap1.andnot_inplace(&treemap2);

assert_eq!(treemap1.cardinality(), 2);
assert!(treemap1.contains(15));
assert!(treemap1.contains(u64::MAX - 10));
assert!(!treemap1.contains(u64::MAX));
assert!(!treemap1.contains(35));

let mut treemap3 = Treemap::new();
treemap3.add(15);
let treemap4 = Treemap::new();
treemap3.andnot_inplace(&treemap4);
assert_eq!(treemap3.cardinality(), 1);
assert!(treemap3.contains(15));

pub fn to_vec(&self) -> Vec<u64>

Returns a vector containing all of the integers stored in the Treemap in a sorted order.

use std::u64;
use croaring::Treemap;

let mut treemap = Treemap::new();
treemap.add(25);
treemap.add(15);
treemap.add(u64::MAX);

assert_eq!(treemap.to_vec(), [15, 25, u64::MAX]);

pub fn get_serialized_size_in_bytes<S: Serializer>(&self) -> usize

Computes the serialized size in bytes of the treemap in format S.

pub fn serialize<S: Serializer>(&self) -> Vec<u8>

Serializes the treemap to a slice of bytes in format S.

Examples

use croaring::{Treemap, Portable};

let treemap: Treemap = (1..5).collect();

let serialized_buffer = treemap.serialize::<Portable>();

let deserialized_treemap = Treemap::deserialize::<Portable>(&serialized_buffer);

assert_eq!(treemap, deserialized_treemap);

pub fn serialize_into<'a, S: Serializer>( &self, dst: &'a mut Vec<u8> ) -> &'a [u8]

Serializes a treemap to a slice of bytes in format S, re-using existing capacity

dst is not cleared, data is added after any existing data. Returns the added slice of dst. If dst is empty, it is guaranteed to hold only the serialized data after this call

Examples

use croaring::{Treemap, Portable};

let original_treemap_1: Treemap = (1..5).collect();
let original_treemap_2: Treemap = (1..10).collect();

let mut data = Vec::new();
for treemap in [original_treemap_1, original_treemap_2] {
    data.clear();
    let serialized_output = treemap.serialize_into::<Portable>(&mut data);
    // do something with serialized_output
}

pub fn serialize_into_writer<S: Serializer, W: Write>( &self, writer: W ) -> Result<usize>

Serializes a treemap to a writer in format S.

Returns the number of bytes written to the writer.

Note that the Frozen format requires alignment to 32 bytes. This function assumes the writer starts at an aligned position (and cannot check this).

Examples

use croaring::{Treemap, Portable};
use std::io::Cursor;

let treemap: Treemap = (1..5).collect();

let mut cursor = Cursor::new(Vec::new());
treemap.serialize_into_writer::<Portable, _>(&mut cursor).unwrap();

let deserialized_treemap = Treemap::try_deserialize::<Portable>(cursor.into_inner().as_slice()).unwrap();

assert_eq!(treemap, deserialized_treemap);

pub fn try_deserialize<D: Deserializer>(buffer: &[u8]) -> Option<Self>

Given a serialized treemap as slice of bytes in format S, returns a Bitmap instance. See example of Self::serialize function.

On invalid input returns None.

Examples

use croaring::{Treemap, Portable};

let original_treemap: Treemap = (1..5).collect();
let serialized_buffer = original_treemap.serialize::<Portable>();

let deserialized_treemap = Treemap::try_deserialize::<Portable>(&serialized_buffer);
assert_eq!(original_treemap, deserialized_treemap.unwrap());

let invalid_buffer: Vec<u8> = vec![3];
let deserialized_treemap = Treemap::try_deserialize::<Portable>(&invalid_buffer);
assert!(deserialized_treemap.is_none());

pub fn deserialize<D: Deserializer>(buffer: &[u8]) -> Self

Given a serialized treemap as slice of bytes in format S , returns a treemap instance. See example of Self::serialize function.

On invalid input returns empty treemap.

pub fn of(elements: &[u64]) -> Self

Creates a new treemap from a slice of u64 integers

Examples

use std::u64;
use croaring::Treemap;

let elements = vec![1, 2, u64::MAX];

let treemap = Treemap::of(&elements);

let mut treemap2 = Treemap::new();

for element in &elements {
    treemap2.add(*element);
}

assert!(treemap.contains(1));
assert!(treemap.contains(2));
assert!(treemap.contains(u64::MAX));
assert!(!treemap.contains(3));
assert_eq!(treemap, treemap2);

pub fn run_optimize(&mut self) -> bool

Compresses treemap’s bitmaps. Returns true if any of the bitmaps were modified.

Examples

use croaring::Treemap;

let mut treemap: Treemap = (100..1000).collect();

assert_eq!(treemap.cardinality(), 900);
assert!(treemap.run_optimize());

pub fn remove_run_compression(&mut self) -> bool

Removes run-length encoding from treemap’s bitmaps. Returns true if change was made to any of the bitmaps.

Examples

use croaring::Treemap;

let mut treemap: Treemap = (100..1000).collect();

assert_eq!(treemap.cardinality(), 900);
assert!(treemap.run_optimize());
assert!(treemap.remove_run_compression());

impl Treemap

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

Returns an iterator over each value stored in the bitmap. Returned values are ordered in ascending order.

Examples

use std::u64;
use croaring::Treemap;

let mut treemap = Treemap::new();
treemap.add(4);
treemap.add(3);
treemap.add(2);
treemap.add(2);
treemap.add(u64::MAX);
let mut iterator = treemap.iter();

assert_eq!(iterator.next(), Some(2));
assert_eq!(iterator.next(), Some(3));
assert_eq!(iterator.next(), Some(4));
assert_eq!(iterator.next(), Some(u64::MAX));
assert_eq!(iterator.next(), None);

Trait Implementations

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

fn bitand(self, other: &'a Treemap) -> Treemap

Syntactic sugar for .and

Examples

use croaring::Treemap;

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

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

let treemap3 = &treemap1 & &treemap2;

assert!(treemap3.contains(1));
assert!(!treemap3.contains(2));

type Output = Treemap

The resulting type after applying the & operator.

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

fn bitand(self, other: &'a Treemap) -> Treemap

Syntactic sugar for .and

Examples

use croaring::Treemap;

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

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

let treemap3 = treemap1 & &treemap2;

assert!(treemap3.contains(1));
assert!(!treemap3.contains(2));

type Output = Treemap

The resulting type after applying the & operator.

impl BitAnd<Treemap> for Treemap

fn bitand(self, other: Treemap) -> Treemap

Syntactic sugar for .and

Examples

use std::u64;
use croaring::Treemap;

let mut treemap1 = Treemap::new();
treemap1.add(u64::MAX);

let mut treemap2 = Treemap::new();
treemap2.add(1);
treemap2.add(u64::MAX);

let treemap3 = treemap1 & treemap2;

assert!(treemap3.contains(u64::MAX));
assert!(!treemap3.contains(1));

type Output = Treemap

The resulting type after applying the & operator.

impl BitAndAssign<Treemap> for Treemap

fn bitand_assign(&mut self, other: Treemap)

Syntactic sugar for .and_inplace

Examples

use croaring::Treemap;

let mut treemap1 = Treemap::new();
treemap1.add(15);

let mut treemap2 = Treemap::new();
treemap2.add(25);

let mut treemap3 = Treemap::new();
treemap3.add(15);

let mut treemap4 = Treemap::new();
treemap4.add(15);
treemap4.add(25);

treemap1 &= treemap2;

assert!(treemap1.cardinality() == 0);
assert!(!treemap1.contains(15));
assert!(!treemap1.contains(25));

treemap3 &= treemap4;

assert!(treemap3.cardinality() == 1);
assert!(treemap3.contains(15));
assert!(!treemap3.contains(25));

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

fn bitor(self, other: &'a Treemap) -> Treemap

Syntatic sugar for .or

Examples

use croaring::Treemap;

let mut treemap1 = Treemap::new();
treemap1.add(15);

let mut treemap2 = Treemap::new();
treemap2.add(25);

let treemap3 = &treemap1 | &treemap2;

assert!(treemap3.cardinality() == 2);
assert!(treemap3.contains(15));
assert!(treemap3.contains(25));

type Output = Treemap

The resulting type after applying the | operator.

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

fn bitor(self, other: &'a Treemap) -> Treemap

Syntatic sugar for .or

Examples

use croaring::Treemap;

let mut treemap1 = Treemap::new();
treemap1.add(15);

let mut treemap2 = Treemap::new();
treemap2.add(25);

let treemap3 = treemap1 | &treemap2;

assert!(treemap3.cardinality() == 2);
assert!(treemap3.contains(15));
assert!(treemap3.contains(25));

type Output = Treemap

The resulting type after applying the | operator.

impl BitOr<Treemap> for Treemap

fn bitor(self, other: Treemap) -> Treemap

Syntatic sugar for .or

Examples

use croaring::Treemap;

let mut treemap1 = Treemap::new();
treemap1.add(15);

let mut treemap2 = Treemap::new();
treemap2.add(25);

let treemap3 = treemap1 | treemap2;

assert!(treemap3.cardinality() == 2);
assert!(treemap3.contains(15));
assert!(treemap3.contains(25));

type Output = Treemap

The resulting type after applying the | operator.

impl BitOrAssign<Treemap> for Treemap

fn bitor_assign(&mut self, other: Treemap)

Syntatic sugar for .or_inplace

Examples

use croaring::Treemap;

let mut treemap1 = Treemap::new();
treemap1.add(15);

let mut treemap2 = Treemap::new();
treemap2.add(25);

treemap1 |= treemap2;

assert!(treemap1.cardinality() == 2);
assert!(treemap1.contains(15));
assert!(treemap1.contains(25));

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

fn bitxor(self, other: &'a Treemap) -> Treemap

Syntatic sugar for .xor

Examples

use std::u64;
use croaring::Treemap;

let mut treemap1 = Treemap::new();
treemap1.add(15);
treemap1.add(u64::MAX);

let mut treemap2 = Treemap::new();
treemap2.add(u64::MAX);
treemap2.add(35);

let treemap3 = &treemap1 ^ &treemap2;

assert!(treemap3.cardinality() == 2);
assert!(treemap3.contains(15));
assert!(!treemap3.contains(u64::MAX));
assert!(treemap3.contains(35));

type Output = Treemap

The resulting type after applying the ^ operator.

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

fn bitxor(self, other: &'a Treemap) -> Treemap

Syntatic sugar for .xor

Examples

use std::u64;
use croaring::Treemap;

let mut treemap1 = Treemap::new();
treemap1.add(15);
treemap1.add(u64::MAX);

let mut treemap2 = Treemap::new();
treemap2.add(u64::MAX);
treemap2.add(35);

let treemap3 = treemap1 ^ &treemap2;

assert!(treemap3.cardinality() == 2);
assert!(treemap3.contains(15));
assert!(!treemap3.contains(u64::MAX));
assert!(treemap3.contains(35));

type Output = Treemap

The resulting type after applying the ^ operator.

impl BitXor<Treemap> for Treemap

fn bitxor(self, other: Treemap) -> Treemap

Syntatic sugar for .xor

Examples

use std::u64;
use croaring::Treemap;

let mut treemap1 = Treemap::new();
treemap1.add(15);
treemap1.add(u64::MAX);

let mut treemap2 = Treemap::new();
treemap2.add(u64::MAX);
treemap2.add(35);

let treemap3 = treemap1 ^ treemap2;

assert!(treemap3.cardinality() == 2);
assert!(treemap3.contains(15));
assert!(!treemap3.contains(u64::MAX));
assert!(treemap3.contains(35));

type Output = Treemap

The resulting type after applying the ^ operator.

impl BitXorAssign<Treemap> for Treemap

fn bitxor_assign(&mut self, other: Treemap)

Syntatic sugar for .xor_inplace

Examples

use std::u64;
use croaring::Treemap;

let mut treemap1 = Treemap::new();
treemap1.add(15);
treemap1.add(u64::MAX);

let mut treemap2 = Treemap::new();
treemap2.add(u64::MAX);
treemap2.add(35);

treemap1 ^= treemap2;

assert!(treemap1.cardinality() == 2);
assert!(treemap1.contains(15));
assert!(!treemap1.contains(u64::MAX));
assert!(treemap1.contains(35));

impl Clone for Treemap

fn clone(&self) -> Treemap

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Treemap

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

Formats the value using the given formatter.

impl Default for Treemap

fn default() -> Self

Returns the “default value” for a type.

impl Extend<u64> for Treemap

fn extend<T: IntoIterator<Item = u64>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl FromIterator<u64> for Treemap

fn from_iter<I: IntoIterator<Item = u64>>(iter: I) -> Self

Convenience method for creating treemap from an iterator.

Examples

use std::{u32, u64};
use croaring::Treemap;

let treemap: Treemap = (1..3).chain(u64::from(u32::MAX)+1..u64::from(u32::MAX)+10).collect();

assert!(!treemap.is_empty());
assert!(treemap.contains(1));
assert!(treemap.contains(2));
assert!(treemap.contains(u64::from(u32::MAX)+1));
assert!(treemap.contains(u64::from(u32::MAX)+5));
assert_eq!(treemap.cardinality(), 11);

impl PartialEq<Treemap> for Treemap

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

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

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

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

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

fn sub(self, other: &'a Treemap) -> Treemap

Syntatic sugar for .andnot

Examples

use std::u64;
use croaring::Treemap;

let mut treemap1 = Treemap::new();

treemap1.add(15);
treemap1.add(u64::MAX);

let mut treemap2 = Treemap::new();

treemap2.add(25);
treemap1.add(u64::MAX);

let treemap3 = &treemap1 - &treemap2;

assert_eq!(treemap3.cardinality(), 1);
assert!(treemap3.contains(15));
assert!(!treemap3.contains(u64::MAX));
assert!(!treemap3.contains(35));

type Output = Treemap

The resulting type after applying the - operator.

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

fn sub(self, other: &'a Treemap) -> Treemap

Syntatic sugar for .andnot

Examples

use std::u64;
use croaring::Treemap;

let mut treemap1 = Treemap::new();

treemap1.add(15);
treemap1.add(u64::MAX);

let mut treemap2 = Treemap::new();

treemap2.add(25);
treemap2.add(u64::MAX);

let treemap3 = treemap1 - &treemap2;

assert_eq!(treemap3.cardinality(), 1);
assert!(treemap3.contains(15));
assert!(!treemap3.contains(u64::MAX));
assert!(!treemap3.contains(35));

type Output = Treemap

The resulting type after applying the - operator.

impl Sub<Treemap> for Treemap

fn sub(self, other: Treemap) -> Treemap

Syntatic sugar for .andnot

Examples

use std::u64;
use croaring::Treemap;

let mut treemap1 = Treemap::new();

treemap1.add(15);
treemap1.add(u64::MAX);

let mut treemap2 = Treemap::new();

treemap2.add(u64::MAX);
treemap2.add(35);

let treemap3 = treemap1 - treemap2;

assert_eq!(treemap3.cardinality(), 1);
assert!(treemap3.contains(15));
assert!(!treemap3.contains(u64::MAX));
assert!(!treemap3.contains(35));

type Output = Treemap

The resulting type after applying the - operator.

impl SubAssign<Treemap> for Treemap

fn sub_assign(&mut self, other: Treemap)

Syntatic sugar for .andnot_inplace

Examples

use std::u64;
use croaring::Treemap;

let mut treemap1 = Treemap::new();

treemap1.add(15);
treemap1.add(u64::MAX);

let mut treemap2 = Treemap::new();

treemap2.add(25);
treemap2.add(u64::MAX);

treemap1.andnot_inplace(&treemap2);

assert_eq!(treemap1.cardinality(), 1);
assert!(treemap1.contains(15));
assert!(!treemap1.contains(u64::MAX));
assert!(!treemap1.contains(35));

impl Eq for Treemap

impl StructuralEq for Treemap

impl StructuralPartialEq for Treemap