Struct diem_bitvec::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 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;
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 & 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 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.

Trait Implementations

impl Arbitrary for BitVec

type Parameters = <Vec<u8, Global> as Arbitrary>::Parameters

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

type Strategy = Map<<Vec<u8, Global> as Arbitrary>::Strategy, fn(_: Vec<u8, Global>) -> BitVec>

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

fn arbitrary_with(_top: 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

Returns a new BitVec that is a bitwise AND 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 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: &Rhs) -> bool

This method 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 StructuralEq for BitVec

impl StructuralPartialEq for BitVec