Struct gf::support::bitvec::BitVec

pub struct BitVec { /* fields omitted */ }

Growable bit vector.

Total order

Bit vectors have total order implemented as shortlex order: if two vectors differ in length, the shorter one is less; otherwise, two vectors of equal length compare lexicographically (or, equivalently, as unsigned integers).

Implementations

impl BitVec

pub fn new() -> Self

Create an empty vector.

pub fn new_all_zeros(bit_len: usize) -> Self

Create an all-zero vector of given length.

pub fn new_concat<I>(parts: I) -> Self where
    I: IntoIterator<Item = BitVec>, 

Create a vector as a concatenation of some parts.

pub fn with_capacity(bit_capacity: usize) -> Self

Create an empty vector with preallocated capacity.

pub fn from_byte_slice(slice: &[u8], endianness: Endianness) -> Self

Create a vector from bytes with given endianness.

Example

assert_eq!(BitVec::from_byte_slice(&[0x12, 0x34], Endianness::Little), 0x3412u16.into());
assert_eq!(BitVec::from_byte_slice(&[0x12, 0x34], Endianness::Big), 0x1234u16.into());

pub fn from_byte_slice_prefix(
    slice: &[u8],
    endianness: Endianness,
    bit_len: usize
) -> Self

Create a vector from a bit prefix of bytes with given endianness.

Errors

• Panics if the slice is shorter than the prefix length.

pub fn from_str(src: &str) -> Self

Convert a string slice to a little endian bit vector of its UTF-8 bytes.

pub fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseBitVecError>

Convert a string slice in a given base to a bit vector.

The resulting vector will have no leading zero bits, meaning that it can be empty if the input is zero.

Errors

• Panics if radix is not in the range from 2 to 36.

Example

assert_eq!(BitVec::from_str_radix("C001a1D3", 16), Ok(BitVec::from(0xC001_A1D3u32)));
assert_eq!(BitVec::from_str_radix("011010001", 2), Ok(BitVec::from(0xD1u8)));
assert_eq!(BitVec::from_str_radix("0", 10), Ok(BitVec::new()));

pub fn is_empty(&self) -> bool

Return whether the vector is empty.

pub fn len(&self) -> usize

Return bit length of the vector.

pub fn is_all_zeros(&self) -> bool

Check whether the vector has no set bits, i.e. is either empty or has zero value.

pub fn get(&self, bit_index: usize) -> bool

Return bit value at bit_index.

Errors

• Panics on out-of-bound indexing.

pub fn get_slice<R: RangeBounds<usize>>(&self, bit_range: R) -> BitSlice<'_>

Return slice for bit_range.

Errors

• Panics on out-of-bound indexing.

pub fn set(&mut self, bit_index: usize, value: bool)

Set bit value at bit_index.

Errors

• Panics on out-of-bound indexing.

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

Push a bit at the end of the vector.

pub fn append(&mut self, src: &Self)

Append a vector at the end of this one.

pub fn as_bit_slice(&self) -> BitSlice<'_>

Borrow the vector as an immutable bit slice.

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

Borrow the vector as an immutable byte slice in little endian order.

The slice may have extra zero bits at the end, padding it up to a whole byte.

pub fn to_byte_vec(&self, endianness: Endianness) -> Cow<'_, [u8]>

Convert the vector to a byte vector with given endianness.

The vector may have extra zero bits at the end, padding it up to a whole byte.

pub fn as_str(&self) -> Result<&str, Utf8Error>

Borrow the vector as a string slice.

pub fn cast_into<T: CastFromBitVec>(self) -> Result<T, CastFromBitVecError>

Cast the vector into an integer type.

pub fn resize(&mut self, new_bit_len: usize, signedness: Signedness)

Truncate or extend the vector in place using given signedness.

pub fn resized(&self, new_bit_len: usize, signedness: Signedness) -> Self

Return a truncated or extended vector using given signedness.

pub fn truncate(&mut self, min_bit_len: usize, signedness: Signedness)

Remove duplicate leading bits in place using given signedness, stopping when length becomes less than or equal to min_bit_len.

The resulting vector will be empty if the original vector had only zero bits.

pub fn limbs<'a>(&'a self) -> impl Iterator<Item = u128> + 'a

Return an iterator over the 128-bit limbs of the vector in little endian order.

Unused bits in the most significant limb are always zero.

pub fn limbs_rev<'a>(&'a self) -> impl Iterator<Item = u128> + 'a

Return an iterator over the 128-bit limbs of the vector in big endian order.

Unused bits in the most significant limb are always zero.

pub fn from_big_int(src: &BigInt, len: usize) -> Self

Convert from num_bigint::BigInt, resizing to the given number of bits.

pub fn from_big_uint(src: &BigUint, len: usize) -> Self

Convert from num_bigint::BigUint, resizing to the giving number of bits.

pub fn from_big_uint_shortest(src: &BigUint) -> Self

Convert from num_bigint::BigUint, using the minimum possible number of bits.

This method returns an empty vector when src is zero.

pub fn to_big_int(&self) -> BigInt

Convert to num_bigint::BigInt, treating the value as signed.

pub fn to_big_uint(&self) -> BigUint

Convert to num_bigint::BigUint, treating the value as unsigned.

Trait Implementations

impl Binary for BitVec

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

Formats the value using the given formatter.

impl BitSeq for BitVec

fn bit_len(&self) -> usize

Return sequence length in bits.

fn get_bit(&self, bit_index: usize) -> bool

Return bit value at bit_index.

fn lsb(&self) -> Option<bool>

Return the first, least significant bit.

fn msb(&self) -> Option<bool>

Return the last, most significant bit. If the sequence is interpreted as a signed integer or an IEEE 754 floating-point number, this is also the sign bit.

impl BitSeqMut for BitVec

fn set_bit(&mut self, bit_index: usize, value: bool)

Set bit value at bit_index.

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 ConstSpaceState<BitVec, FlatLattice<BitVec>> for ConcreteSpaceState

fn load(
    &mut self,
    span: SpaceSpan<BitVec>
) -> (FlatLattice<BitVec>, FlatLattice<BitVec>)

Load from the space.

fn load_result(&mut self, span: SpaceSpan<A>) -> Result<V, V>

Load from the space returning a Result.

impl ConstSpaceState<BitVec, FlatLattice<Expr>> for SymbolicSpaceState

fn load(
    &mut self,
    span: SpaceSpan<BitVec>
) -> (FlatLattice<Expr>, FlatLattice<Expr>)

Load from the space.

fn load_result(&mut self, span: SpaceSpan<A>) -> Result<V, V>

Load from the space returning a Result.

impl Debug for BitVec

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

Formats the value using the given formatter.

impl Default for BitVec

fn default() -> Self

Returns the "default value" for a type.

impl Display for BitVec

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

Formats the value using the given formatter.

impl Eq for BitVec

impl Extend<bool> for BitVec

fn extend<I: IntoIterator<Item = bool>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl Extend<u128> for BitVec

fn extend<I: IntoIterator<Item = u128>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl Extend<u16> for BitVec

fn extend<I: IntoIterator<Item = u16>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl Extend<u32> for BitVec

fn extend<I: IntoIterator<Item = u32>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl Extend<u64> for BitVec

fn extend<I: IntoIterator<Item = u64>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl Extend<u8> for BitVec

fn extend<I: IntoIterator<Item = u8>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a> From<BitSlice<'a>> for BitVec

fn from(src: BitSlice<'a>) -> Self

Performs the conversion.

impl From<bool> for BitVec

fn from(src: bool) -> Self

Performs the conversion.

impl From<i128> for BitVec

fn from(src: i128) -> Self

Performs the conversion.

impl From<i16> for BitVec

fn from(src: i16) -> Self

Performs the conversion.

impl From<i32> for BitVec

fn from(src: i32) -> Self

Performs the conversion.

impl From<i64> for BitVec

fn from(src: i64) -> Self

Performs the conversion.

impl From<i8> for BitVec

fn from(src: i8) -> Self

Performs the conversion.

impl From<u128> for BitVec

fn from(src: u128) -> Self

Performs the conversion.

impl From<u16> for BitVec

fn from(src: u16) -> Self

Performs the conversion.

impl From<u32> for BitVec

fn from(src: u32) -> Self

Performs the conversion.

impl From<u64> for BitVec

fn from(src: u64) -> Self

Performs the conversion.

impl From<u8> for BitVec

fn from(src: u8) -> Self

Performs the conversion.

impl FromIterator<bool> for BitVec

fn from_iter<I: IntoIterator<Item = bool>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<u128> for BitVec

fn from_iter<I: IntoIterator<Item = u128>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<u16> for BitVec

fn from_iter<I: IntoIterator<Item = u16>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<u32> for BitVec

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

Creates a value from an iterator.

impl FromIterator<u64> for BitVec

fn from_iter<I: IntoIterator<Item = u64>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<u8> for BitVec

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

Creates a value from an iterator.

impl Hash for BitVec

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl Index<usize> for BitVec

type Output = bool

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl LowerHex for BitVec

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

Formats the value using the given formatter.

impl Ord for BitVec

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

This method returns an Ordering between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl PartialEq<BitVec> for BitVec

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

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

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

This method tests for !=.

impl PartialOrd<BitVec> for BitVec

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 SpaceState<BitVec, FlatLattice<BitVec>> for ConcreteSpaceState

fn store(
    &mut self,
    span: SpaceSpan<BitVec>,
    value: FlatLattice<BitVec>
) -> (Option<()>, FlatLattice<BitVec>)

Store to the space.

fn store_result(
    &mut self,
    span: SpaceSpan<A>,
    value: V
) -> Result<Option<()>, V>

Store to the space returning a Result.

impl SpaceState<BitVec, FlatLattice<Expr>> for SymbolicSpaceState

fn store(
    &mut self,
    span: SpaceSpan<BitVec>,
    value: FlatLattice<Expr>
) -> (Option<()>, FlatLattice<Expr>)

Store to the space.

fn store_result(
    &mut self,
    span: SpaceSpan<A>,
    value: V
) -> Result<Option<()>, V>

Store to the space returning a Result.

impl ToBigInt for BitVec

fn to_bigint(&self) -> Option<BigInt>

Converts the value of self to a BigInt.

impl ToBigUint for BitVec

fn to_biguint(&self) -> Option<BigUint>

Converts the value of self to a BigUint.

impl TryFrom<BitVec> for bool

type Error = TryFromBitVecError

The type returned in the event of a conversion error.

fn try_from(src: BitVec) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<BitVec> for i8

type Error = TryFromBitVecError

The type returned in the event of a conversion error.

fn try_from(src: BitVec) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<BitVec> for u128

type Error = TryFromBitVecError

The type returned in the event of a conversion error.

fn try_from(src: BitVec) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<BitVec> for i16

type Error = TryFromBitVecError

The type returned in the event of a conversion error.

fn try_from(src: BitVec) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<BitVec> for i32

type Error = TryFromBitVecError

The type returned in the event of a conversion error.

fn try_from(src: BitVec) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<BitVec> for i64

type Error = TryFromBitVecError

The type returned in the event of a conversion error.

fn try_from(src: BitVec) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<BitVec> for i128

type Error = TryFromBitVecError

The type returned in the event of a conversion error.

fn try_from(src: BitVec) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<BitVec> for u8

type Error = TryFromBitVecError

The type returned in the event of a conversion error.

fn try_from(src: BitVec) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<BitVec> for u16

type Error = TryFromBitVecError

The type returned in the event of a conversion error.

fn try_from(src: BitVec) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<BitVec> for u32

type Error = TryFromBitVecError

The type returned in the event of a conversion error.

fn try_from(src: BitVec) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<BitVec> for u64

type Error = TryFromBitVecError

The type returned in the event of a conversion error.

fn try_from(src: BitVec) -> Result<Self, Self::Error>

Performs the conversion.

impl UpperHex for BitVec

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

Formats the value using the given formatter.