Struct baa::BitVecValue

pub struct BitVecValue { /* private fields */ }

Owned bit-vector value.

Implementations

impl BitVecValue

pub fn from_bit_str(value: &str) -> Self

Parse a string of 1s and 0s. The width of the resulting value is the number of digits.

pub fn from_u64(value: u64, width: WidthInt) -> Self

pub fn from_i64(value: i64, width: WidthInt) -> Self

pub fn from_bool(value: bool) -> Self

pub fn from_bytes_le(bytes: &[u8], bits: WidthInt) -> Self

pub fn zero(width: WidthInt) -> Self

pub fn ones(width: WidthInt) -> Self

pub fn tru() -> Self

pub fn fals() -> Self

Trait Implementations

impl<V: BitVecOps> Add<&V> for &BitVecValue

type Output = BitVecValue

The resulting type after applying the + operator.

fn add(self, rhs: &V) -> Self::Output

Performs the + operation.

impl BitVecMutOps for BitVecValue

fn words_mut(&mut self) -> &mut [Word]

fn assign<'a>(&mut self, value: impl Into<BitVecValueRef<'a>>)

fn mask_msb(&mut self)

ensures that all unused bits in the most significant word are set to zero

fn clear(&mut self)

sets all bits to zero

fn assign_ones(&mut self)

sets all bits to one

fn assign_from_u64(&mut self, value: u64)

fn assign_from_i64(&mut self, value: i64)

fn assign_from_str_radix( &mut self, value: &str, radix: u32, ) -> Result<WidthInt, ParseIntError>

impl BitVecOps for BitVecValue

fn width(&self) -> WidthInt

fn words(&self) -> &[Word]

fn to_bit_str(&self) -> String

Convert to a string of 1s and 0s.

fn to_bytes_le(&self) -> Vec<u8>

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

Returns value as a bool iff the value is a 1-bit value.

fn to_u64(&self) -> Option<u64>

Returns the value as a 64-bit unsigned integer if the value can be represented

fn to_i64(&self) -> Option<i64>

Returns the value as a 64-bit signed integer if the value can be represented

fn is_zero(&self) -> bool

fn is_negative(&self) -> bool

fn add<R: BitVecOps>(&self, rhs: &R) -> BitVecValue

fn sub<R: BitVecOps>(&self, rhs: &R) -> BitVecValue

fn shift_left<R: BitVecOps>(&self, rhs: &R) -> BitVecValue

fn shift_right<R: BitVecOps>(&self, rhs: &R) -> BitVecValue

fn arithmetic_shift_right<R: BitVecOps>(&self, rhs: &R) -> BitVecValue

fn mul<R: BitVecOps>(&self, rhs: &R) -> BitVecValue

fn and<R: BitVecOps>(&self, rhs: &R) -> BitVecValue

fn or<R: BitVecOps>(&self, rhs: &R) -> BitVecValue

fn xor<R: BitVecOps>(&self, rhs: &R) -> BitVecValue

fn is_equal<R: BitVecOps + ?Sized>(&self, rhs: &R) -> bool

fn is_not_equal<R: BitVecOps + ?Sized>(&self, rhs: &R) -> bool

fn is_greater<R: BitVecOps + ?Sized>(&self, rhs: &R) -> bool

fn is_greater_or_equal<R: BitVecOps + ?Sized>(&self, rhs: &R) -> bool

fn is_less<R: BitVecOps + ?Sized>(&self, rhs: &R) -> bool

fn is_less_or_equal<R: BitVecOps + ?Sized>(&self, rhs: &R) -> bool

fn is_greater_signed<R: BitVecOps + ?Sized>(&self, rhs: &R) -> bool

fn is_greater_or_equal_signed<R: BitVecOps + ?Sized>(&self, rhs: &R) -> bool

fn is_less_signed<R: BitVecOps + ?Sized>(&self, rhs: &R) -> bool

fn is_less_or_equal_signed<R: BitVecOps + ?Sized>(&self, rhs: &R) -> bool

fn slice(&self, msb: WidthInt, lsb: WidthInt) -> BitVecValue

fn sign_extend(&self, by: WidthInt) -> BitVecValue

fn zero_extend(&self, by: WidthInt) -> BitVecValue

fn not(&self) -> BitVecValue

fn negate(&self) -> BitVecValue

fn concat<R: BitVecOps + ?Sized>(&self, rhs: &R) -> BitVecValue

impl Clone for BitVecValue

fn clone(&self) -> BitVecValue

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BitVecValue

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

Formats the value using the given formatter.

impl<'a> From<&'a BitVecValue> for BitVecValueRef<'a>

fn from(value: &'a BitVecValue) -> Self

Converts to this type from the input type.

impl<'a> From<&'a mut BitVecValue> for BitVecValueMutRef<'a>

fn from(value: &'a mut BitVecValue) -> Self

Converts to this type from the input type.

impl From<bool> for BitVecValue

fn from(value: bool) -> Self

Converts to this type from the input type.

impl<V: BitVecOps> PartialEq<V> for BitVecValue

fn eq(&self, other: &V) -> 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<V: BitVecOps> Sub<&V> for &BitVecValue

type Output = BitVecValue

The resulting type after applying the - operator.

fn sub(self, rhs: &V) -> Self::Output

Performs the - operation.

impl Eq for BitVecValue