[][src]Struct croaring::Bitmap

pub struct Bitmap { /* fields omitted */ }

Methods

impl Bitmap[src]

pub fn create() -> Self[src]

Creates a new bitmap (initially empty)

Examples

use croaring::Bitmap;

let bitmap = Bitmap::create();

assert!(bitmap.is_empty());

pub fn create_with_capacity(capacity: u32) -> Self[src]

Creates a new bitmap (initially empty) with a provided container-storage capacity (it is a performance hint).

Examples

use croaring::Bitmap;

let bitmap = Bitmap::create_with_capacity(100_000);

assert!(bitmap.is_empty());

pub fn add_many(&mut self, elements: &[u32])[src]

Add the integer element to the bitmap

Examples

use croaring::Bitmap;

let mut bitmap = Bitmap::create();
bitmap.add_many(&[1, 2, 3]);

assert!(!bitmap.is_empty());
assert!(bitmap.contains(1));
assert!(bitmap.contains(2));
assert!(bitmap.contains(3));

pub fn add(&mut self, element: u32)[src]

Add the integer element to the bitmap

Examples

use croaring::Bitmap;

let mut bitmap = Bitmap::create();
bitmap.add(1);

assert!(!bitmap.is_empty());

pub fn add_checked(&mut self, element: u32) -> bool[src]

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::Bitmap;

let mut bitmap = Bitmap::create();
assert!(bitmap.add_checked(1));
assert!(!bitmap.add_checked(1));

pub fn add_range(&mut self, range: Range<u64>)[src]

Add all values in range [range_min, range_max)

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add_range((1..3));

assert!(!bitmap1.is_empty());
assert!(bitmap1.contains(1));
assert!(bitmap1.contains(2));
assert!(!bitmap1.contains(3));

let mut bitmap2 = Bitmap::create();
bitmap2.add_range((3..1));
assert!(bitmap2.is_empty());

let mut bitmap3 = Bitmap::create();
bitmap3.add_range((3..3));
assert!(bitmap3.is_empty());

pub fn remove_range(&mut self, range: Range<u64>)[src]

Remove all values in range [range_min, range_max)

Examples

use croaring::Bitmap;

let mut bitmap = Bitmap::create();
bitmap.add_range((1..4));
assert!(!bitmap.is_empty());

bitmap.remove_range((1..3));

assert!(!bitmap.contains(1));
assert!(!bitmap.contains(2));
assert!(bitmap.contains(3));

pub fn add_range_closed(&mut self, range: Range<u32>)[src]

Add all values in range [range_min, range_max]

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add_range_closed((1..3));

assert!(!bitmap1.is_empty());
assert!(bitmap1.contains(1));
assert!(bitmap1.contains(2));
assert!(bitmap1.contains(3));

let mut bitmap2 = Bitmap::create();
bitmap2.add_range_closed((3..1));
assert!(bitmap2.is_empty());

let mut bitmap3 = Bitmap::create();
bitmap3.add_range_closed((3..3));
assert!(!bitmap3.is_empty());
assert!(bitmap3.contains(3));

pub fn remove_range_closed(&mut self, range: Range<u32>)[src]

Remove all values in range [range_min, range_max]

Examples

use croaring::Bitmap;

let mut bitmap = Bitmap::create();
bitmap.add_range((1..4));
assert!(!bitmap.is_empty());

bitmap.remove_range_closed((1..3));

assert!(!bitmap.contains(1));
assert!(!bitmap.contains(2));
assert!(!bitmap.contains(3));

pub fn contains_range(&mut self, range: Range<u64>) -> bool[src]

Check whether a range of values of range are present

Examples

use croaring::Bitmap;

let mut bitmap = Bitmap::create();
bitmap.add_range((1..3));
assert!(bitmap.contains_range((1..3)));

pub fn remove(&mut self, element: u32)[src]

Remove the integer element from the bitmap

Examples

use croaring::Bitmap;

let mut bitmap = Bitmap::create();
bitmap.add(1);
bitmap.remove(1);

assert!(bitmap.is_empty());

pub fn remove_checked(&mut self, element: u32) -> bool[src]

Remove the integer element from the bitmap. Returns true if a the value was removed, false if the value was present in the bitmap.

Examples

use croaring::Bitmap;

let mut bitmap = Bitmap::create();
bitmap.add(1);
assert!(bitmap.remove_checked(1));
assert!(!bitmap.remove_checked(1));

pub fn contains(&self, element: u32) -> bool[src]

Contains returns true if the integer element is contained in the bitmap

Examples

use croaring::Bitmap;

let mut bitmap = Bitmap::create();
bitmap.add(1);

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

pub fn range_cardinality(&self, range: Range<u64>) -> u64[src]

Returns number of elements in range [range_start, range_end).

Examples

use croaring::Bitmap;

let mut bitmap = Bitmap::create();
bitmap.add(1);
bitmap.add(3);
bitmap.add(4);

assert_eq!(bitmap.range_cardinality((0..1)), 0);
assert_eq!(bitmap.range_cardinality((0..2)), 1);
assert_eq!(bitmap.range_cardinality((2..5)), 2);
assert_eq!(bitmap.range_cardinality((0..5)), 3);

pub fn cardinality(&self) -> u64[src]

Returns the number of integers contained in the bitmap

Examples

use croaring::Bitmap;

let mut bitmap = Bitmap::create();
bitmap.add(1);

assert_eq!(bitmap.cardinality(), 1);

bitmap.add(2);

assert_eq!(bitmap.cardinality(), 2);

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

And computes the intersection between two bitmaps and returns the result as a new bitmap

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(1);

let mut bitmap2 = Bitmap::create();
bitmap2.add(1);
bitmap2.add(2);

let bitmap3 = bitmap1.and(&bitmap2);

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

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

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

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(15);

let mut bitmap2 = Bitmap::create();
bitmap2.add(25);

let mut bitmap3 = Bitmap::create();
bitmap3.add(15);

let mut bitmap4 = Bitmap::create();
bitmap4.add(15);
bitmap4.add(25);

bitmap1.and_inplace(&bitmap2);

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

bitmap3.and_inplace(&bitmap4);

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

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

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

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(15);

let mut bitmap2 = Bitmap::create();
bitmap2.add(25);

let bitmap3 = bitmap1.or(&bitmap2);

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

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

Computes the union between two bitmaps and stores the result in the current bitmap.

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(15);

let mut bitmap2 = Bitmap::create();
bitmap2.add(25);

bitmap1.or_inplace(&bitmap2);

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

pub fn fast_or(bitmaps: &[&Bitmap]) -> Self[src]

Computes the union between many bitmaps quickly, as opposed to having to call or() repeatedly. Returns the result as a new bitmap.

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(15);

let mut bitmap2 = Bitmap::create();
bitmap2.add(25);

let mut bitmap3 = Bitmap::create();
bitmap3.add(35);

let bitmap4 = Bitmap::fast_or(&[&bitmap1, &bitmap2, &bitmap3]);

assert_eq!(bitmap4.cardinality(), 3);
assert!(bitmap4.contains(15));
assert!(bitmap4.contains(25));
assert!(bitmap4.contains(25));

pub fn fast_or_heap(bitmaps: &[&Bitmap]) -> Self[src]

Compute the union of 'number' bitmaps using a heap. This can sometimes be faster than Bitmap::fast_or.

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(15);

let mut bitmap2 = Bitmap::create();
bitmap2.add(25);

let mut bitmap3 = Bitmap::create();
bitmap3.add(35);

let bitmap4 = Bitmap::fast_or_heap(&[&bitmap1, &bitmap2, &bitmap3]);

assert_eq!(bitmap4.cardinality(), 3);
assert!(bitmap4.contains(15));
assert!(bitmap4.contains(25));
assert!(bitmap4.contains(25));

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

Computes the symmetric difference (xor) between two bitmaps and returns new bitmap.

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(15);
bitmap1.add(25);

let mut bitmap2 = Bitmap::create();
bitmap2.add(25);
bitmap2.add(35);

let bitmap3 = bitmap1.xor(&bitmap2);

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

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

Inplace version of roaring_bitmap_xor, stores result in current bitmap.

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(15);
bitmap1.add(25);

let mut bitmap2 = Bitmap::create();
bitmap2.add(25);
bitmap2.add(35);

bitmap1.xor_inplace(&bitmap2);

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

pub fn fast_xor(bitmaps: &[&Bitmap]) -> Self[src]

Computes the symmetric difference (xor) between multiple bitmaps and returns new bitmap as a result.

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(15);
bitmap1.add(25);

let mut bitmap2 = Bitmap::create();
bitmap2.add(25);
bitmap2.add(35);

let bitmap3 = Bitmap::fast_xor(&[&bitmap1, &bitmap2]);

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

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

Computes the difference between two bitmaps and returns the result.

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();

bitmap1.add(15);
bitmap1.add(25);

let mut bitmap2 = Bitmap::create();

bitmap2.add(25);
bitmap2.add(35);

let bitmap3 = bitmap1.andnot(&bitmap2);

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

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

Computes the difference between two bitmaps and stores the result in the current bitmap.

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();

bitmap1.add(15);
bitmap1.add(25);

let mut bitmap2 = Bitmap::create();

bitmap2.add(25);
bitmap2.add(35);

bitmap1.andnot_inplace(&bitmap2);

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

pub fn flip(&self, range: Range<u64>) -> Self[src]

Negates the bits in the given range (i.e., [rangeStart..rangeEnd)), any integer present in this range and in the bitmap is removed. Returns result as a new bitmap.

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(4);

let bitmap2 = bitmap1.flip((1..3));

assert_eq!(bitmap2.cardinality(), 3);
assert!(bitmap2.contains(1));
assert!(bitmap2.contains(2));
assert!(!bitmap2.contains(3));
assert!(bitmap2.contains(4));

pub fn flip_inplace(&mut self, range: Range<u64>)[src]

Negates the bits in the given range (i.e., [rangeStart..rangeEnd)), any integer present in this range and in the bitmap is removed. Stores the result in the current bitmap.

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(4);
bitmap1.flip_inplace((1..3));

assert_eq!(bitmap1.cardinality(), 3);
assert!(bitmap1.contains(1));
assert!(bitmap1.contains(2));
assert!(!bitmap1.contains(3));
assert!(bitmap1.contains(4));

pub fn to_vec(&self) -> Vec<u32>[src]

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

use croaring::Bitmap;

let mut bitmap = Bitmap::create();
bitmap.add(15);
bitmap.add(25);

assert_eq!(bitmap.to_vec(), [15, 25]);
assert!(bitmap.to_vec() != [10, 15, 25]);

pub fn get_serialized_size_in_bytes(&self) -> usize[src]

Computes the serialized size in bytes of the Bitmap.

pub fn serialize(&self) -> Vec<u8>[src]

Serializes a bitmap to a slice of bytes.

Examples

use croaring::Bitmap;

let original_bitmap: Bitmap = (1..5).collect();

let serialized_buffer = original_bitmap.serialize();

let deserialized_bitmap = Bitmap::deserialize(&serialized_buffer);

assert_eq!(original_bitmap, deserialized_bitmap);

pub fn deserialize(buffer: &[u8]) -> Self[src]

Given a serialized bitmap as slice of bytes returns a bitmap instance. See example of #serialize function.

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

Creates a new bitmap from a slice of u32 integers

Examples

use croaring::Bitmap;

let elements = vec![1, 2];

let bitmap = Bitmap::of(&elements);

let mut bitmap2 = Bitmap::create();

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

assert!(bitmap.contains(1));
assert!(bitmap.contains(2));
assert!(!bitmap.contains(3));
assert_eq!(bitmap, bitmap2);

pub fn run_optimize(&mut self) -> bool[src]

Compresses of the bitmap. Returns true if the bitmap was modified.

Examples

use croaring::Bitmap;

let mut bitmap: Bitmap = (100..1000).collect();

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

pub fn remove_run_compression(&mut self) -> bool[src]

Removes run-length encoding even when it is more space efficient. Returns true if a change was applied.

Examples

use croaring::Bitmap;

let mut bitmap: Bitmap = (100..1000).collect();

assert_eq!(bitmap.cardinality(), 900);

bitmap.run_optimize();

assert!(bitmap.remove_run_compression());
assert!(!bitmap.remove_run_compression());

pub fn is_empty(&self) -> bool[src]

Returns true if the Bitmap is empty. Faster than doing: bitmap.cardinality() == 0)

Examples

use croaring::Bitmap;

let mut bitmap = Bitmap::create();

assert!(bitmap.is_empty());

bitmap.add(1);

assert!(!bitmap.is_empty());

pub fn is_subset(&self, other: &Self) -> bool[src]

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

Examples

use croaring::Bitmap;

let bitmap1: Bitmap = (5..10).collect();
let bitmap2: Bitmap = (5..8).collect();
let bitmap3: Bitmap = (5..10).collect();
let bitmap4: Bitmap = (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: &Self) -> bool[src]

Return true if all the elements of Self are in &other and &other is strictly greater than Self.

Examples

use croaring::Bitmap;

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

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

pub fn intersect(&self, other: &Self) -> bool[src]

Return true if Self and &other intersect

Examples

use croaring::Bitmap;

let bitmap1: Bitmap = (1..5).collect();
let bitmap2: Bitmap = (5..9).collect();
let bitmap3: Bitmap = (3..7).collect();

assert_eq!(bitmap1.intersect(&bitmap2), false);
assert_eq!(bitmap1.intersect(&bitmap3), true);
assert_eq!(bitmap2.intersect(&bitmap3), true);

pub fn jaccard_index(&self, other: &Self) -> f64[src]

Return the Jaccard index between Self and &other

use croaring::Bitmap;

let bitmap1: Bitmap = (1..5).collect();
let bitmap2: Bitmap = (5..9).collect();
let bitmap3: Bitmap = (3..9).collect();

assert_eq!(bitmap1.jaccard_index(&bitmap2), 0.0);
assert_eq!(bitmap1.jaccard_index(&bitmap3), 0.25);
assert_eq!(bitmap2.jaccard_index(&bitmap3), 0.6666666666666666);

pub fn and_cardinality(&self, other: &Self) -> u64[src]

Return the size of the intersection between Self and &other

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(1);

let mut bitmap2 = Bitmap::create();
bitmap2.add(1);
bitmap2.add(2);

assert_eq!(bitmap1.and_cardinality(&bitmap2), 1);

pub fn or_cardinality(&self, other: &Self) -> u64[src]

Return the size of the union between Self and &other

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(15);

let mut bitmap2 = Bitmap::create();
bitmap2.add(25);

assert_eq!(bitmap1.or_cardinality(&bitmap2), 2);

pub fn andnot_cardinality(&self, other: &Self) -> u64[src]

Return the size of the difference between Self and &other

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();

bitmap1.add(15);
bitmap1.add(25);

let mut bitmap2 = Bitmap::create();

bitmap2.add(25);
bitmap2.add(35);

assert_eq!(bitmap1.andnot_cardinality(&bitmap2), 1);

pub fn xor_cardinality(&self, other: &Self) -> u64[src]

Return the size of the symmetric difference between Self and &other

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(15);
bitmap1.add(25);

let mut bitmap2 = Bitmap::create();
bitmap2.add(25);
bitmap2.add(35);

assert_eq!(bitmap1.xor_cardinality(&bitmap2), 2);

pub fn minimum(&self) -> u32[src]

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

Examples

use croaring::Bitmap;

let mut bitmap: Bitmap = (5..10).collect();
let empty_bitmap: Bitmap = Bitmap::create();

assert_eq!(bitmap.minimum(), 5);
assert_eq!(empty_bitmap.minimum(), std::u32::MAX);

bitmap.add(3);

assert_eq!(bitmap.minimum(), 3);

pub fn maximum(&self) -> u32[src]

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

Examples

use croaring::Bitmap;

let mut bitmap: Bitmap = (5..10).collect();
let empty_bitmap: Bitmap = Bitmap::create();

assert_eq!(bitmap.maximum(), 9);
assert_eq!(empty_bitmap.maximum(), 0);

bitmap.add(15);

assert_eq!(bitmap.maximum(), 15);

pub fn rank(&self, x: u32) -> u64[src]

Rank returns the number of values smaller or equal to x.

Examples

use croaring::Bitmap;

let mut bitmap: Bitmap = (5..10).collect();

assert_eq!(bitmap.rank(8), 4);

bitmap.add(15);

assert_eq!(bitmap.rank(11), 5);

pub fn select(&self, rank: u32) -> Option<u32>[src]

Select returns the element having the designated rank, if it exists If the size of the roaring bitmap is strictly greater than rank, then this function returns element of given rank wrapped in Some. Otherwise, it returns None.

Examples

use croaring::Bitmap;

let bitmap: Bitmap = (5..10).collect();

assert_eq!(bitmap.select(0), Some(5));
assert_eq!(bitmap.select(1), Some(6));
assert_eq!(bitmap.select(2), Some(7));
assert_eq!(bitmap.select(3), Some(8));
assert_eq!(bitmap.select(4), Some(9));
assert_eq!(bitmap.select(5), None);

pub fn statistics(&self) -> Statistics[src]

Returns statistics about the composition of a roaring bitmap.

Examples

use croaring::Bitmap;

let mut bitmap: Bitmap = (1..100).collect();
let statistics = bitmap.statistics();

assert_eq!(statistics.n_containers, 1);
assert_eq!(statistics.n_array_containers, 1);
assert_eq!(statistics.n_run_containers, 0);
assert_eq!(statistics.n_bitset_containers, 0);
assert_eq!(statistics.n_values_array_containers, 99);
assert_eq!(statistics.n_values_run_containers, 0);
assert_eq!(statistics.n_values_bitset_containers, 0);
assert_eq!(statistics.n_bytes_array_containers, 198);
assert_eq!(statistics.n_bytes_run_containers, 0);
assert_eq!(statistics.n_bytes_bitset_containers, 0);
assert_eq!(statistics.max_value, 99);
assert_eq!(statistics.min_value, 1);
assert_eq!(statistics.sum_value, 4950);
assert_eq!(statistics.cardinality, 99);

bitmap.run_optimize();
let statistics = bitmap.statistics();

assert_eq!(statistics.n_containers, 1);
assert_eq!(statistics.n_array_containers, 0);
assert_eq!(statistics.n_run_containers, 1);
assert_eq!(statistics.n_bitset_containers, 0);
assert_eq!(statistics.n_values_array_containers, 0);
assert_eq!(statistics.n_values_run_containers, 99);
assert_eq!(statistics.n_values_bitset_containers, 0);
assert_eq!(statistics.n_bytes_array_containers, 0);
assert_eq!(statistics.n_bytes_run_containers, 6);
assert_eq!(statistics.n_bytes_bitset_containers, 0);
assert_eq!(statistics.max_value, 99);
assert_eq!(statistics.min_value, 1);
assert_eq!(statistics.sum_value, 4950);
assert_eq!(statistics.cardinality, 99);

impl Bitmap[src]

pub fn iter(&self) -> BitmapIterator[src]

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

Examples

use croaring::Bitmap;

let mut bitmap = Bitmap::create();
bitmap.add(4);
bitmap.add(3);
bitmap.add(2);
let mut iterator = bitmap.iter();

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

Trait Implementations

impl Send for Bitmap[src]

impl Sync for Bitmap[src]

impl PartialEq<Bitmap> for Bitmap[src]

#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0
[src]

This method tests for !=.

impl Clone for Bitmap[src]

fn clone(&self) -> Bitmap[src]

Create a copy of a Bitmap

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(11);

let bitmap2 = bitmap1.clone();

assert_eq!(bitmap1, bitmap2);

fn clone_from(&mut self, source: &Self)
1.0.0
[src]

Performs copy-assignment from source. Read more

impl Drop for Bitmap[src]

impl Debug for Bitmap[src]

impl Sub<Bitmap> for Bitmap[src]

type Output = Bitmap

The resulting type after applying the - operator.

fn sub(self, other: Bitmap) -> Bitmap[src]

Syntatic sugar for .andnot

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();

bitmap1.add(15);
bitmap1.add(25);

let mut bitmap2 = Bitmap::create();

bitmap2.add(25);
bitmap2.add(35);

let bitmap3 = bitmap1 - bitmap2;

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

impl<'a> Sub<&'a Bitmap> for Bitmap[src]

type Output = Bitmap

The resulting type after applying the - operator.

fn sub(self, other: &'a Bitmap) -> Bitmap[src]

Syntatic sugar for .andnot

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();

bitmap1.add(15);
bitmap1.add(25);

let mut bitmap2 = Bitmap::create();

bitmap2.add(25);
bitmap2.add(35);

let bitmap3 = bitmap1 - &bitmap2;

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

impl<'a, 'b> Sub<&'a Bitmap> for &'b Bitmap[src]

type Output = Bitmap

The resulting type after applying the - operator.

fn sub(self, other: &'a Bitmap) -> Bitmap[src]

Syntatic sugar for .andnot

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();

bitmap1.add(15);
bitmap1.add(25);

let mut bitmap2 = Bitmap::create();

bitmap2.add(25);
bitmap2.add(35);

let bitmap3 = &bitmap1 - &bitmap2;

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

impl SubAssign<Bitmap> for Bitmap[src]

fn sub_assign(&mut self, other: Bitmap)[src]

Syntatic sugar for .andnot_inplace

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();

bitmap1.add(15);
bitmap1.add(25);

let mut bitmap2 = Bitmap::create();

bitmap2.add(25);
bitmap2.add(35);

bitmap1.andnot_inplace(&bitmap2);

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

impl BitAnd<Bitmap> for Bitmap[src]

type Output = Bitmap

The resulting type after applying the & operator.

fn bitand(self, other: Bitmap) -> Bitmap[src]

Syntactic sugar for .and

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(1);

let mut bitmap2 = Bitmap::create();
bitmap2.add(1);
bitmap2.add(2);

let bitmap3 = bitmap1 & bitmap2;

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

impl<'a> BitAnd<&'a Bitmap> for Bitmap[src]

type Output = Bitmap

The resulting type after applying the & operator.

fn bitand(self, other: &'a Bitmap) -> Bitmap[src]

Syntactic sugar for .and

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(1);

let mut bitmap2 = Bitmap::create();
bitmap2.add(1);
bitmap2.add(2);

let bitmap3 = bitmap1 & &bitmap2;

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

impl<'a, 'b> BitAnd<&'a Bitmap> for &'b Bitmap[src]

type Output = Bitmap

The resulting type after applying the & operator.

fn bitand(self, other: &'a Bitmap) -> Bitmap[src]

Syntactic sugar for .and

Examples

use croaring::Bitmap;

let mut bitmap1: Bitmap = Bitmap::create();
bitmap1.add(1);

let mut bitmap2 = Bitmap::create();
bitmap2.add(1);
bitmap2.add(2);

let bitmap3 = &bitmap1 & &bitmap2;

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

impl BitOr<Bitmap> for Bitmap[src]

type Output = Bitmap

The resulting type after applying the | operator.

fn bitor(self, other: Bitmap) -> Bitmap[src]

Syntatic sugar for .or

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(15);

let mut bitmap2 = Bitmap::create();
bitmap2.add(25);

let bitmap3 = bitmap1 | bitmap2;

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

impl<'a> BitOr<&'a Bitmap> for Bitmap[src]

type Output = Bitmap

The resulting type after applying the | operator.

fn bitor(self, other: &'a Bitmap) -> Bitmap[src]

Syntatic sugar for .or

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(15);

let mut bitmap2 = Bitmap::create();
bitmap2.add(25);

let bitmap3 = bitmap1 | &bitmap2;

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

impl<'a, 'b> BitOr<&'a Bitmap> for &'b Bitmap[src]

type Output = Bitmap

The resulting type after applying the | operator.

fn bitor(self, other: &'a Bitmap) -> Bitmap[src]

Syntatic sugar for .or

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(15);

let mut bitmap2 = Bitmap::create();
bitmap2.add(25);

let bitmap3 = &bitmap1 | &bitmap2;

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

impl BitXor<Bitmap> for Bitmap[src]

type Output = Bitmap

The resulting type after applying the ^ operator.

fn bitxor(self, other: Bitmap) -> Bitmap[src]

Syntatic sugar for .xor

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(15);
bitmap1.add(25);

let mut bitmap2 = Bitmap::create();
bitmap2.add(25);
bitmap2.add(35);

let bitmap3 = bitmap1 ^ bitmap2;

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

impl<'a> BitXor<&'a Bitmap> for Bitmap[src]

type Output = Bitmap

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Bitmap) -> Bitmap[src]

Syntatic sugar for .xor

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(15);
bitmap1.add(25);

let mut bitmap2 = Bitmap::create();
bitmap2.add(25);
bitmap2.add(35);

let bitmap3 = bitmap1 ^ &bitmap2;

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

impl<'a, 'b> BitXor<&'a Bitmap> for &'b Bitmap[src]

type Output = Bitmap

The resulting type after applying the ^ operator.

fn bitxor(self, other: &'a Bitmap) -> Bitmap[src]

Syntatic sugar for .xor

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(15);
bitmap1.add(25);

let mut bitmap2 = Bitmap::create();
bitmap2.add(25);
bitmap2.add(35);

let bitmap3 = &bitmap1 ^ &bitmap2;

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

impl BitAndAssign<Bitmap> for Bitmap[src]

fn bitand_assign(&mut self, other: Bitmap)[src]

Syntactic sugar for .and_inplace

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(15);

let mut bitmap2 = Bitmap::create();
bitmap2.add(25);

let mut bitmap3 = Bitmap::create();
bitmap3.add(15);

let mut bitmap4 = Bitmap::create();
bitmap4.add(15);
bitmap4.add(25);

bitmap1 &= bitmap2;

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

bitmap3 &= bitmap4;

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

impl BitOrAssign<Bitmap> for Bitmap[src]

fn bitor_assign(&mut self, other: Bitmap)[src]

Syntatic sugar for .or_inplace

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(15);

let mut bitmap2 = Bitmap::create();
bitmap2.add(25);

bitmap1 |= bitmap2;

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

impl BitXorAssign<Bitmap> for Bitmap[src]

fn bitxor_assign(&mut self, other: Bitmap)[src]

Syntatic sugar for .xor_inplace

Examples

use croaring::Bitmap;

let mut bitmap1 = Bitmap::create();
bitmap1.add(15);
bitmap1.add(25);

let mut bitmap2 = Bitmap::create();
bitmap2.add(25);
bitmap2.add(35);

bitmap1 ^= bitmap2;

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

impl FromIterator<u32> for Bitmap[src]

fn from_iter<I: IntoIterator<Item = u32>>(iter: I) -> Self[src]

Convenience method for creating bitmap from iterator.

Examples

use croaring::Bitmap;

let bitmap: Bitmap = (1..3).collect();

assert!(!bitmap.is_empty());
assert!(bitmap.contains(1));
assert!(bitmap.contains(2));
assert_eq!(bitmap.cardinality(), 2);

Blanket Implementations

impl<T, U> Into for T where
    U: From<T>, 
[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T> From for T[src]

impl<T, U> TryFrom for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T> Borrow for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> BorrowMut for T where
    T: ?Sized
[src]

impl<T, U> TryInto for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.