Struct BitVec 

pub struct BitVec { /* private fields */ }

BitVec represents a bit vector that supports 4 operations:

1. Marking a position as set.
2. Checking if a position is set.
3. Count set bits.
4. Get the index of the last set bit.

Internally, it stores a vector of u8’s (as Vec).

• The first 8 positions of the bit vector are encoded in the first element of the vector, the next 8 are encoded in the second element, and so on.
• Bits are read from left to right. For instance, in the following bitvec [0b0001_0000, 0b0000_0000, 0b0000_0000, 0b0000_0001], the 3rd and 31st positions are set.
• Each bit of a u8 is set to 1 if the position is set and to 0 if it’s not.
• We only allow setting positions upto u16::MAX. As a result, the size of the inner vector is limited to 8192 (= 65536 / 8).
• Once a bit has been set, it cannot be unset. As a result, the inner vector cannot shrink.
• The positions can be set in any order.
• A position can set more than once – it remains set after the first time.

Examples:

use aptos_bitvec::BitVec;
use std::ops::BitAnd;

let mut bv = BitVec::default();
bv.set(2);
bv.set(5);
assert!(bv.is_set(2));
assert!(bv.is_set(5));
assert_eq!(false, bv.is_set(0));
assert_eq!(bv.count_ones(), 2);
assert_eq!(bv.last_set_bit(), Some(5));

// A bitwise AND of BitVec can be performed by using the `&` operator.
let mut bv1 = BitVec::default();
bv1.set(2);
bv1.set(3);
let mut bv2 = BitVec::default();
bv2.set(2);
let intersection = bv1.bitand(&bv2);
assert!(intersection.is_set(2));
assert_eq!(false, intersection.is_set(3));

Implementations

impl BitVec

pub fn with_num_bits(num_bits: u16) -> Self

Initialize with buckets that can fit in num_bits.

pub fn set(&mut self, pos: u16)

Sets the bit at position @pos.

pub fn is_set(&self, pos: u16) -> bool

Checks if the bit at position @pos is set.

pub fn all_zeros(&self) -> bool

Return true if the BitVec is all zeros.

pub fn count_ones(&self) -> u32

Returns the number of set bits.

pub fn last_set_bit(&self) -> Option<u16>

Returns the index of the last set bit.

pub fn iter_ones(&self) -> impl Iterator<Item = usize> + '_

Return an Iterator over all ‘1’ bit indexes.

pub fn num_buckets(&self) -> usize

Return the number of buckets.

pub fn required_buckets(num_bits: u16) -> usize

Number of buckets require for num_bits.

Trait Implementations

impl BitAnd for &BitVec

fn bitand(self, other: Self) -> Self::Output

Returns a new BitVec that is a bitwise AND of two BitVecs.

type Output = BitVec

The resulting type after applying the & operator.

impl BitOr for &BitVec

fn bitor(self, other: Self) -> Self::Output

Returns a new BitVec that is a bitwise OR of two BitVecs.

type Output = BitVec

The resulting type after applying the | operator.

impl Clone for BitVec

fn clone(&self) -> BitVec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BitVec

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

Formats the value using the given formatter.

impl Default for BitVec

fn default() -> BitVec

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BitVec

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<BitVec> for Vec<u8>

fn from(bitvec: BitVec) -> Self

Converts to this type from the input type.

impl From<Vec<bool>> for BitVec

fn from(bits: Vec<bool>) -> Self

Converts to this type from the input type.

impl From<Vec<u8>> for BitVec

fn from(raw_bytes: Vec<u8>) -> Self

Converts to this type from the input type.

impl FromIterator<u8> for BitVec

fn from_iter<T: IntoIterator<Item = u8>>(iter: T) -> Self

Creates a value from an iterator.

impl PartialEq for BitVec

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for BitVec

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for BitVec

impl StructuralPartialEq for BitVec