Struct BitVecValueRef 

pub struct BitVecValueRef<'a>(/* private fields */);

Bit-vector value that does not own its storage.

Implementations

impl<'a> BitVecValueRef<'a>

pub fn new(words: &'a [Word], width: WidthInt) -> Self

Trait Implementations

impl BitVecOps for BitVecValueRef<'_>

fn width(&self) -> WidthInt

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

fn to_bit_str(&self) -> String

Convert to a string of 1s and 0s.

fn to_bit_str_signed(&self) -> String

Convert to a string of 1s and 0s with a - if the value is negative.

fn to_hex_str(&self) -> String

Convert to a string of hex characters

fn to_dec_str(&self) -> String

Convert to a string of a decimal number. No leading zeros.

fn to_hex_str_signed(&self) -> String

Convert to a string of hex characters with a - if the value is negative.

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_true(&self) -> bool

fn is_false(&self) -> bool

fn is_zero(&self) -> bool

fn is_one(&self) -> bool

fn is_all_ones(&self) -> bool

fn is_negative(&self) -> bool

fn is_pow_2(&self) -> Option<WidthInt>

fn min_width(&self) -> WidthInt

Computes the minimum number of bits that are necessary to represent the current value. This corresponds to the position of the most significant 1 plus one.

fn bit_set_intervals(&self) -> Vec<Range<WidthInt>>

Computes all ranges for which the bits are one.

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 is_bit_set(&self, pos: WidthInt) -> bool

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<'a> Borrow<BitVecValueRef<'a>> for BitVecValue

fn borrow(&self) -> &BitVecValueRef<'a>

Immutably borrows from an owned value.

impl<'a> Clone for BitVecValueRef<'a>

fn clone(&self) -> BitVecValueRef<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BitVecValueRef<'_>

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<BitVecValueRef<'a>> for BitVecValue

fn from(value: BitVecValueRef<'a>) -> Self

Converts to this type from the input type.

impl<'a> Hash for BitVecValueRef<'a>

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, I> IndexToRef<I, BitVecValueRef<'a>> for &'a [Word]

where I: Borrow<BitVecValueIndex>,

fn get_ref(self, index: I) -> BitVecValueRef<'a>

impl<O: BitVecOps> PartialEq<O> for BitVecValueRef<'_>

fn eq(&self, other: &O) -> 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<'a> Copy for BitVecValueRef<'a>

impl Eq for BitVecValueRef<'_>