Struct indexed_bitvec::bits::Bits

pub struct Bits<T: Deref<Target = [u8]>>(_);

A bitvector stored as a sequence of bytes (most significant bit first).

Methods

impl<T: Deref<Target = [u8]>> Bits<T>

pub fn from_bytes(bytes: T, len: u64) -> Option<Self>

pub fn all_bytes(&self) -> &[u8]

All of the bytes stored in the byte sequence: not just the ones actually used.

pub fn len(&self) -> u64

The number of bits in the storage.

pub fn bytes(&self) -> &[u8]

The used bytes of the byte sequence: bear in mind some of the bits in the last byte may be unused.

pub fn decompose(self) -> (T, u64)

Deconstruct the bits storage to get back what it was constructed from.

pub fn get(&self, idx_bits: u64) -> Option<bool>

Get the byte at a specific index.

Returns None for out-of-bounds.

use indexed_bitvec::Bits;
let bits = Bits::from_bytes(vec![0xFE, 0xFE], 15).unwrap();
assert_eq!(bits.get(0), Some(true));
assert_eq!(bits.get(7), Some(false));
assert_eq!(bits.get(14), Some(true));
assert_eq!(bits.get(15), None);

pub fn count_ones(&self) -> u64

Count the set bits (O(n)).

use indexed_bitvec::Bits;
let bits = Bits::from_bytes(vec![0xFE, 0xFE], 15).unwrap();
assert_eq!(bits.count_ones(), 14);
assert_eq!(bits.count_zeros(), 1);
assert_eq!(bits.count_ones() + bits.count_zeros(), bits.len());

pub fn count_zeros(&self) -> u64

Count the unset bits (O(n)).

use indexed_bitvec::Bits;
let bits = Bits::from_bytes(vec![0xFE, 0xFE], 15).unwrap();
assert_eq!(bits.count_ones(), 14);
assert_eq!(bits.count_zeros(), 1);
assert_eq!(bits.count_ones() + bits.count_zeros(), bits.len());

pub fn rank_ones(&self, idx: u64) -> Option<u64>

Count the set bits before a position in the bits (O(n)).

Returns None it the index is out of bounds.

use indexed_bitvec::Bits;
let bits = Bits::from_bytes(vec![0xFE, 0xFE], 15).unwrap();
assert!((0..bits.len()).all(|idx|
    bits.rank_ones(idx).unwrap()
    + bits.rank_zeros(idx).unwrap()
    == (idx as u64)));
assert_eq!(bits.rank_ones(7), Some(7));
assert_eq!(bits.rank_zeros(7), Some(0));
assert_eq!(bits.rank_ones(8), Some(7));
assert_eq!(bits.rank_zeros(8), Some(1));
assert_eq!(bits.rank_ones(9), Some(8));
assert_eq!(bits.rank_zeros(9), Some(1));
assert_eq!(bits.rank_ones(15), None);

pub fn rank_zeros(&self, idx: u64) -> Option<u64>

Count the unset bits before a position in the bits (O(n)).

Returns None it the index is out of bounds.

use indexed_bitvec::Bits;
let bits = Bits::from_bytes(vec![0xFE, 0xFE], 15).unwrap();
assert!((0..bits.len()).all(|idx|
    bits.rank_ones(idx).unwrap()
    + bits.rank_zeros(idx).unwrap()
    == (idx as u64)));
assert_eq!(bits.rank_ones(7), Some(7));
assert_eq!(bits.rank_zeros(7), Some(0));
assert_eq!(bits.rank_ones(8), Some(7));
assert_eq!(bits.rank_zeros(8), Some(1));
assert_eq!(bits.rank_ones(9), Some(8));
assert_eq!(bits.rank_zeros(9), Some(1));
assert_eq!(bits.rank_ones(15), None);

pub fn select_ones(&self, target_rank: u64) -> Option<u64>

Find the position of a set bit by its rank (O(n)).

Returns None if no suitable bit is found. It is always the case otherwise that rank_ones(result) == Some(target_rank) and get(result) == Some(true).

use indexed_bitvec::Bits;
let bits = Bits::from_bytes(vec![0xFE, 0xFE], 15).unwrap();
assert_eq!(bits.select_ones(6), Some(6));
assert_eq!(bits.select_ones(7), Some(8));
assert_eq!(bits.select_zeros(0), Some(7));
assert_eq!(bits.select_zeros(1), None);

pub fn select_zeros(&self, target_rank: u64) -> Option<u64>

Find the position of an unset bit by its rank (O(n)).

Returns None if no suitable bit is found. It is always the case otherwise that rank_zeros(result) == Some(target_rank) and get(result) == Some(false).

use indexed_bitvec::Bits;
let bits = Bits::from_bytes(vec![0xFE, 0xFE], 15).unwrap();
assert_eq!(bits.select_ones(6), Some(6));
assert_eq!(bits.select_ones(7), Some(8));
assert_eq!(bits.select_zeros(0), Some(7));
assert_eq!(bits.select_zeros(1), None);

pub fn clone_ref(&self) -> Bits<&[u8]>

Create a reference to these same bits.

impl<T: DerefMut<Target = [u8]>> Bits<T>

pub fn all_bytes_mut(&mut self) -> &mut [u8]

pub fn set(&mut self, idx_bits: u64, to: bool) -> Result<(), &'static str>

Set the byte at a specific index.

Returns an error if the index is out of bounds.

use indexed_bitvec::Bits;
let mut bits = Bits::from_bytes(vec![0xFE, 0xFE], 15).unwrap();
assert_eq!(bits.get(0), Some(true));
assert_eq!(bits.get(7), Some(false));
assert_eq!(bits.get(14), Some(true));
assert_eq!(bits.get(15), None);
assert!(bits.set(0, false).is_ok());
assert_eq!(bits.get(0), Some(false));
assert!(bits.set(0, true).is_ok());
assert_eq!(bits.get(0), Some(true));
assert!(bits.set(7, false).is_ok());
assert_eq!(bits.get(7), Some(false));
assert!(bits.set(14, false).is_ok());
assert_eq!(bits.get(14), Some(false));
assert!(bits.set(15, false).is_err());

impl Bits<Vec<u8>>

pub fn push(&mut self, bit: bool)

Add a specific bit to the end of the vector.

This will enlarge the used section of bits (corresponding to Bits::len) and overwrite any content already in the newly used storage.

use indexed_bitvec::Bits;
let mut bits = Bits::from_bytes(vec![0x80], 0).unwrap();
assert_eq!(0x80, bits.all_bytes()[0]);
assert_eq!(None, bits.get(0));
bits.push(false);
assert_eq!(0x00, bits.all_bytes()[0]);
assert_eq!(Some(false), bits.get(0));
bits.push(true);
assert_eq!(0x40, bits.all_bytes()[0]);
assert_eq!(Some(true), bits.get(1));
for _ in 0..6 { bits.push(false) };
assert_eq!(0x40, bits.all_bytes()[0]);
assert_eq!(1, bits.all_bytes().len());
bits.push(true);
assert_eq!(2, bits.all_bytes().len());
assert_eq!(0x80, bits.all_bytes()[1]);
assert_eq!(Some(true), bits.get(8));

impl<T: Deref<Target = [u8]>> Bits<T>

Important traits for BitIterator<T>

impl<T: Deref<Target = [u8]>> Iterator for BitIterator<T> type Item = bool;

pub fn iter(&self) -> BitIterator<&[u8]>

Important traits for OneBitIndexIterator<T>

impl<T: Deref<Target = [u8]>> Iterator for OneBitIndexIterator<T> type Item = u64;

pub fn into_iter_one_bits(self) -> OneBitIndexIterator<T>

Important traits for OneBitIndexIterator<T>

impl<T: Deref<Target = [u8]>> Iterator for OneBitIndexIterator<T> type Item = u64;

pub fn iter_one_bits(&self) -> OneBitIndexIterator<&[u8]>

Important traits for ZeroBitIndexIterator<T>

impl<T: Deref<Target = [u8]>> Iterator for ZeroBitIndexIterator<T> type Item = u64;

pub fn into_iter_zero_bits(self) -> ZeroBitIndexIterator<T>

Important traits for ZeroBitIndexIterator<T>

impl<T: Deref<Target = [u8]>> Iterator for ZeroBitIndexIterator<T> type Item = u64;

pub fn iter_zero_bits(&self) -> ZeroBitIndexIterator<&[u8]>

Trait Implementations

impl<'a, T: Deref<Target = [u8]>> From<&'a Bits<T>> for BitsRef<'a>

fn from(bits: &'a Bits<T>) -> Self

Performs the conversion.

impl<'a> From<Bits<&'a [u8]>> for BitsRef<'a>

fn from(bits: Bits<&'a [u8]>) -> Self

Performs the conversion.

impl<'a> From<BitsRef<'a>> for Bits<&'a [u8]>

fn from(bits: BitsRef<'a>) -> Self

Performs the conversion.

impl<T: Deref<Target = [u8]>> IntoIterator for Bits<T>

type Item = bool

The type of the elements being iterated over.

type IntoIter = BitIterator<T>

Which kind of iterator are we turning this into?

Important traits for BitIterator<T>

impl<T: Deref<Target = [u8]>> Iterator for BitIterator<T> type Item = bool;

fn into_iter(self) -> BitIterator<T>

Creates an iterator from a value.

impl<T: Deref<Target = [u8]>> Eq for Bits<T>

impl<T: Deref<Target = [u8]>> PartialOrd<Bits<T>> for Bits<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Copy + Deref<Target = [u8]>> Copy for Bits<T>

impl<T: Deref<Target = [u8]>> PartialEq<Bits<T>> for Bits<T>

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

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

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

This method tests for !=.

impl<T: Clone + Deref<Target = [u8]>> Clone for Bits<T>

fn clone(&self) -> Bits<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Deref<Target = [u8]>> Ord for Bits<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

impl<T: Debug + Deref<Target = [u8]>> Debug for Bits<T>

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

Formats the value using the given formatter.

impl<T: Serialize + Deref<Target = [u8]>> Serialize for Bits<T>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where     S: Serializer,

Serialize this value into the given Serde serializer.

impl<'de, T: Deserialize<'de> + Deref<Target = [u8]>> Deserialize<'de> for Bits<T>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where     D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.