Struct croaring::treemap::Treemap

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

Fields

map: BTreeMap<u32, Bitmap>

Implementations

impl Treemap

pub fn create() -> Self

Creates an empty Treemap.

Examples

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

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

Examples

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

let mut treemap = Treemap::create();
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 contains(&self, value: u64) -> bool

use croaring::Treemap;

let mut treemap = Treemap::create();

pub fn is_empty(&self) -> bool

Returns true if the Treemap is empty.

Examples

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

let mut treemap = Treemap::create();

assert!(treemap.is_empty());

treemap.add(u64::MAX);

assert!(!treemap.is_empty());

pub fn clear(&mut self)

Empties the Treemap

Examples

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

let mut treemap = Treemap::create();

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::create();
treemap.add(u64::MAX);
treemap.remove(u64::MAX);

assert!(treemap.is_empty());

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::create();
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 std::u64::MAX if the set is empty.

Examples

use croaring::Treemap;

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

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::create();
let empty_treemap: Treemap = Treemap::create();

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::create();
treemap1.add(u64::MAX);

let mut treemap2 = Treemap::create();
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::create();
treemap1.add(u64::MAX);

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

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

let mut treemap4 = Treemap::create();
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::create();
treemap5.add(u64::MAX);
treemap5.and_inplace(&Treemap::create());
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::create();
treemap1.add(u64::MAX);

let mut treemap2 = Treemap::create();
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::create();
treemap1.add(15);

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

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

let mut bitmap4 = Treemap::create();
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::create();
treemap1.add(15);
treemap1.add(u64::MAX);

let mut treemap2 = Treemap::create();
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::create();
treemap1.add(15);
treemap1.add(25);

let mut treemap2 = Treemap::create();
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::create();
treemap3.add(15);
treemap3.xor_inplace(&Treemap::create());
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::create();

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

let mut treemap2 = Treemap::create();

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::create();

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

let mut treemap2 = Treemap::create();

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::create();
treemap3.add(15);
let treemap4 = Treemap::create();
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::create();
treemap.add(25);
treemap.add(15);
treemap.add(u64::MAX);

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

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::create();

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::create();
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> BitAnd<&'a Treemap> for Treemap

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

Syntactic sugar for .and

Examples

use croaring::Treemap;

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

let mut treemap2 = Treemap::create();
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, '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::create();
treemap1.add(1);

let mut treemap2 = Treemap::create();
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::create();
treemap1.add(u64::MAX);

let mut treemap2 = Treemap::create();
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::create();
treemap1.add(15);

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

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

let mut treemap4 = Treemap::create();
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> BitOr<&'a Treemap> for Treemap

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

Syntatic sugar for .or

Examples

use croaring::Treemap;

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

let mut treemap2 = Treemap::create();
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, '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::create();
treemap1.add(15);

let mut treemap2 = Treemap::create();
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::create();
treemap1.add(15);

let mut treemap2 = Treemap::create();
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::create();
treemap1.add(15);

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

treemap1 |= treemap2;

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

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::create();
treemap1.add(15);
treemap1.add(u64::MAX);

let mut treemap2 = Treemap::create();
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, '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::create();
treemap1.add(15);
treemap1.add(u64::MAX);

let mut treemap2 = Treemap::create();
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::create();
treemap1.add(15);
treemap1.add(u64::MAX);

let mut treemap2 = Treemap::create();
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::create();
treemap1.add(15);
treemap1.add(u64::MAX);

let mut treemap2 = Treemap::create();
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 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 JvmSerializer for Treemap

fn get_serialized_size_in_bytes(&self) -> usize

How many bytes are required to serialize this bitmap with JvmSerializer

Examples

use croaring::Treemap;
use croaring::treemap::JvmSerializer;

let mut treemap = Treemap::create();

for i in 100..1000 {
  treemap.add(i);
}

treemap.add(std::u32::MAX as u64);
treemap.add(std::u64::MAX);

assert_eq!(treemap.get_serialized_size_in_bytes(), 1857);

type Item = Treemap

fn serialize(&self) -> Result<Vec<u8>>

fn deserialize(buffer: &[u8]) -> Result<Self::Item>

impl NativeSerializer for Treemap

fn get_serialized_size_in_bytes(&self) -> usize

How many bytes are required to serialize this bitmap with NativeSerializer

Examples

use croaring::Treemap;
use croaring::treemap::NativeSerializer;

let mut treemap = Treemap::create();

for i in 100..1000 {
  treemap.add(i);
}

treemap.add(std::u32::MAX as u64);
treemap.add(std::u64::MAX);

assert_eq!(treemap.get_serialized_size_in_bytes(), 1860);

type Item = Treemap

fn serialize(&self) -> Result<Vec<u8>>

fn deserialize(buffer: &[u8]) -> Result<Self>

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: &Treemap) -> bool

This method tests for !=.

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::create();

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

let mut treemap2 = Treemap::create();

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<'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::create();

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

let mut treemap2 = Treemap::create();

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 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::create();

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

let mut treemap2 = Treemap::create();

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::create();

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

let mut treemap2 = Treemap::create();

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 StructuralPartialEq for Treemap