Struct BitIndex 

pub struct BitIndex { /* private fields */ }

Structure for accessing individual bits in any structure that implements BitIndexable.

A BitIndex can be used to address any singular bit in an array of up to usize bytes. This structure uses a usize to index the byte portion, and a separate u8 to index the bit of the selected byte. There is also a sign associated with this structure for arithmetic purposes. Attempting to access a bit at a negative position will cause a panic.

Examples

use bitutils2::{BitIndex, BitIndexable};

let v = vec![0b01011100, 0b11001100];
//                ^               ^
//              (0,3)           (1,7)

let i = BitIndex::new(0, 3);
assert_eq!(v.bit_at(&i), 1);

let i = BitIndex::new(1, 7);
assert_eq!(v.bit_at(&i), 0);

Implementations

impl BitIndex

pub const MAX: BitIndex

pub const MIN: BitIndex

pub const fn new(byte: usize, bit: u8) -> BitIndex

Constructs a new BitIndex with the specified byte and bit values. The sign of the result is positive.

pub const fn bytes(byte: usize) -> BitIndex

Constructs a new BitIndex with the specified byte value and bit equal to zero. The sign of the result is positive.

pub const fn bits(bits: usize) -> BitIndex

Constructs a new BitIndex with the specified bit value and byte equal to zero. The sign of the result is positive.

pub const fn zero() -> BitIndex

Constructs a new BitIndex with byte and bit both equal to zero.

pub const fn is_zero(&self) -> bool

Returns true if the byte and bit indices are both zero, regardless of sign.

pub const fn is_positive(&self) -> bool

Returns true if self is positive and false if self is zero or negative

pub const fn is_negative(&self) -> bool

Returns true if self is negative and false if self is zero or positive

pub const fn is_byte_boundary(&self) -> bool

Returns true if self lies on a byte boundary and false otherwise. Functionally equivalent to self.bit() == 0

pub const fn byte(&self) -> usize

Returns the bit portion of this BitIndex.

pub const fn bit(&self) -> u8

Returns the bit portion of this BitIndex.

pub const fn cbit(&self) -> u8

Returns the compliment of the bit portion of this BitIndex (8 - self.bit()).

pub const fn total_bits(&self) -> i128

pub fn ceil(&self) -> BitIndex

Returns a new BitIndex the corresponds to the nearest byte boundary greater than or equal to self.

Example

use bitutils2::BitIndex;

assert_eq!(BitIndex::new(4, 2).ceil(), BitIndex::new(5, 0));

assert_eq!(BitIndex::new(4, 0).ceil(), BitIndex::new(4, 0));

// Negative case
assert_eq!((-BitIndex::new(1, 2)).ceil(), -BitIndex::new(1, 0));

pub const fn abs(&self) -> BitIndex

Returns the absolute value of self

pub fn set_bit(&mut self, bit: u8)

Sets the bit portion of this BitIndex. bit must be less than 8.

pub fn set_byte(&mut self, byte: usize)

Sets the byte portion of this BitIndex

pub fn add_bits(&mut self, nbits: usize)

Adds nbits bits to this BitIndex. The bit and byte portions will be adjusted accordingly to ensure that the bit portion is always less than 8

pub const fn from_i64_bytes(byte: i64) -> BitIndex

pub fn rem_euclid(&self, rhs: &BitIndex) -> BitIndex

Calculates the smallest non-negative value b such that self + b = n * rhs where n is an integer.

Trait Implementations

impl<'a, 'b> Add<&'a BitIndex> for &'b BitIndex

type Output = BitIndex

The resulting type after applying the + operator.

fn add(self, rhs: &'a BitIndex) -> Self::Output

Performs the + operation.

impl Add<&usize> for BitIndex

type Output = BitIndex

The resulting type after applying the + operator.

fn add(self, other: &usize) -> BitIndex

Performs the + operation.

impl Add<usize> for BitIndex

type Output = BitIndex

The resulting type after applying the + operator.

fn add(self, other: usize) -> BitIndex

Performs the + operation.

impl Add for BitIndex

type Output = BitIndex

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<&BitIndex> for BitIndex

fn add_assign(&mut self, other: &BitIndex)

Performs the += operation.

impl AddAssign<&usize> for BitIndex

fn add_assign(&mut self, other: &usize)

Performs the += operation.

impl AddAssign<usize> for BitIndex

fn add_assign(&mut self, other: usize)

Performs the += operation.

impl AddAssign for BitIndex

fn add_assign(&mut self, other: BitIndex)

Performs the += operation.

impl Clone for BitIndex

fn clone(&self) -> BitIndex

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BitIndex

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

Formats the value using the given formatter.

impl Default for BitIndex

fn default() -> BitIndex

Returns the “default value” for a type.

impl Display for BitIndex

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

Formats the value using the given formatter.

impl Div<&BitIndex> for BitIndex

fn div(self, rhs: &BitIndex) -> Self::Output

Performs integer division between self and rhs. Returns the largest integer by which self can be multiplied such that self <= rhs. Output is negative if exactly one of the inputs is negative. Panics if rhs is zero.

Example

use bitutils2::BitIndex;

assert_eq!(BitIndex::new(4, 2) / &BitIndex::new(2, 1), 2);
assert_eq!(BitIndex::new(4, 1) / &BitIndex::new(2, 1), 1);
assert_eq!(BitIndex::new(403, 2) / &BitIndex::new(100, 0), 4);

// Negative case
assert_eq!(-BitIndex::new(4, 2) / &BitIndex::new(2, 1), -2);
assert_eq!(-BitIndex::new(4, 2) / &-BitIndex::new(2, 1), 2);

type Output = i128

The resulting type after applying the / operator.

impl FromStr for BitIndex

type Err = ParseBitIndexError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Mul<i128> for BitIndex

type Output = BitIndex

The resulting type after applying the * operator.

fn mul(self, rhs: i128) -> Self::Output

Performs the * operation.

impl Neg for &BitIndex

type Output = BitIndex

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for BitIndex

type Output = BitIndex

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Ord for BitIndex

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

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for BitIndex

fn eq(&self, other: &BitIndex) -> 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 PartialOrd for BitIndex

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Shl<BitIndex> for BitField

fn shl(self, rhs: BitIndex) -> Self::Output

Returns a BitField with the bits shifted left by the magnitude of rhs if rhs is positive or shifted right if rhs is negative. Bits that are dropped off one side are wrapped around to fill the other side.

Examples

 use bitutils2::{BitField, BitIndex, bx};

 let bf = BitField::from_bin_str("1100 0000 1111 00");
 let bf = bf << bx!(,2);
 assert_eq!(bf, BitField::from_bin_str("0000 0011 1100 11"));
 let bf = bf << bx!(1 ,4);
 assert_eq!(bf, BitField::from_bin_str("1100 0000 1111 00"));

 // Negative bit indexes will result in right shifts
 let bf = bf << -bx!(1 ,4);
 assert_eq!(bf, BitField::from_bin_str("0000 0011 1100 11"));

type Output = BitField

The resulting type after applying the << operator.

impl ShlAssign<BitIndex> for BitField

fn shl_assign(&mut self, rhs: BitIndex)

Transforms self by shifting all bits to the left by the magnitude of rhs if rhs is positive or shifted right if rhs is negative. Bits that are dropped off one side are wrapped around to fill the other side.

Examples

 use bitutils2::{BitField, BitIndex, bx};

 let mut bf = BitField::from_bin_str("1100 0000 1111 00");
 bf <<= bx!(,2);
 assert_eq!(bf, BitField::from_bin_str("0000 0011 1100 11"));
 bf <<= bx!(1, 4);
 assert_eq!(bf, BitField::from_bin_str("1100 0000 1111 00"));

 // Negative bit indexes will result in right shifts
 bf <<= -bx!(1, 4);
 assert_eq!(bf, BitField::from_bin_str("0000 0011 1100 11"));

impl Shr<BitIndex> for BitField

fn shr(self, rhs: BitIndex) -> Self::Output

Returns a BitField with the bits shifted right by the magnitude of rhs if rhs is positive or shifted left if rhs is negative. Bits that are dropped off one side are wrapped around to fill the other side.

Examples

 use bitutils2::{BitField, BitIndex, bx};

 let bf = BitField::from_bin_str("1100 0000 1111 00");
 let bf = bf >> bx!(,2);
 assert_eq!(bf, BitField::from_bin_str("0011 0000 0011 11"));
 let bf = bf >> bx!(1 ,4);
 assert_eq!(bf, BitField::from_bin_str("1100 0000 1111 00"));

 // Negative bit indexes will result in left shifts
 let bf = bf >> -bx!(1 ,4);
 assert_eq!(bf, BitField::from_bin_str("0011 0000 0011 11"));

type Output = BitField

The resulting type after applying the >> operator.

impl ShrAssign<BitIndex> for BitField

fn shr_assign(&mut self, rhs: BitIndex)

Transforms self by shifting all bits to the right by the magnitude of rhs if rhs is positive or shifted left if rhs is negative. Bits that are dropped off one side are wrapped around to fill the other side.

Examples

 use bitutils2::{BitField, BitIndex, bx};

 let mut bf = BitField::from_bin_str("1100 0000 1111 00");
 bf >>= bx!(,2);
 assert_eq!(bf, BitField::from_bin_str("0011 0000 0011 11"));
 bf >>= bx!(1, 4);
 assert_eq!(bf, BitField::from_bin_str("1100 0000 1111 00"));

 // Negative bit indexes will result in left shifts
 bf >>= -bx!(1, 4);
 assert_eq!(bf, BitField::from_bin_str("0011 0000 0011 11"));

impl<'a, 'b> Sub<&'a BitIndex> for &'b BitIndex

type Output = BitIndex

The resulting type after applying the - operator.

fn sub(self, rhs: &'a BitIndex) -> Self::Output

Performs the - operation.

impl Sub for BitIndex

type Output = BitIndex

The resulting type after applying the - operator.

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

Performs the - operation.

impl Copy for BitIndex

impl Eq for BitIndex

impl StructuralPartialEq for BitIndex