Struct diem_bitvec::BitVec

pub struct BitVec { /* fields omitted */ }

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 u8::MAX. As a result, the size of the inner vector is limited to 32 (= 256 / 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 diem_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 set(&mut self, pos: u8)

Sets the bit at position @pos.

pub fn is_set(&self, pos: u8) -> 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<u8>

Returns the index of the last set bit.

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

Return an Iterator over all ‘1’ bit indexes.

Trait Implementations

impl Arbitrary for BitVec

type Parameters = ()

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = Map<VecStrategy<StrategyFor<u8>>, fn(_: Vec<u8>) -> BitVec>

The type of Strategy used to generate values of type Self.

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl BitAnd<&'_ BitVec> 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<&'_ BitVec> 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 copy 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 FromIterator<u8> for BitVec

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

Creates a value from an iterator.

impl PartialEq<BitVec> for BitVec

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

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

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

This method tests for !=.

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