Enum ShiftVariant 

#[repr(u8)]
pub enum ShiftVariant {
    Sll = 0,
    Slr = 1,
    Sar = 2,
    Rotr = 3,
    Sll32 = 4,
    Srl32 = 5,
    Sra32 = 6,
    Rotr32 = 7,
}

A different variants of shifting a value.

Note that there is no shift left arithmetic because it is redundant.

The discriminant is stored in a single byte.

Variants

Sll = 0

Shift logical left.

Slr = 1

Shift logical right.

Sar = 2

Shift arithmetic right.

This is similar to the logical shift right but instead of shifting in 0 bits it will replicate the sign bit.

Rotr = 3

Rotate right.

Rotates bits to the right, with bits shifted off the right end wrapping around to the left.

Sll32 = 4

Shift logical left on 32-bit halves.

Performs independent logical left shifts on the upper and lower 32-bit halves of the word. Only uses the lower 5 bits of the shift amount (0-31).

Srl32 = 5

Shift logical right on 32-bit halves.

Performs independent logical right shifts on the upper and lower 32-bit halves of the word. Only uses the lower 5 bits of the shift amount (0-31).

Sra32 = 6

Shift arithmetic right on 32-bit halves.

Performs independent arithmetic right shifts on the upper and lower 32-bit halves of the word. Sign extends each 32-bit half independently. Only uses the lower 5 bits of the shift amount (0-31).

Rotr32 = 7

Rotate right on 32-bit halves.

Performs independent rotate right operations on the upper and lower 32-bit halves of the word. Bits shifted off the right end wrap around to the left within each 32-bit half. Only uses the lower 5 bits of the shift amount (0-31).

Implementations

impl ShiftVariant

pub const fn from_u8(byte: u8) -> Option<Self>

Decodes a variant from its u8 discriminant.

The discriminants match the #[repr(u8)] layout: 0..=7 map to the eight variants. Any other byte returns None.

pub const fn is_half_word(self) -> bool

Whether this variant operates on the two 32-bit halves independently.

• The *32 family shifts each half on its own.
• It reads only the lower 5 bits of the amount.
• Every other variant acts on the whole 64-bit word.

pub const fn max_amount(self) -> usize

The exclusive upper bound on a valid shift amount for this variant.

• Half-word (*32) variants read only the lower 5 bits, so amounts run 0..32.
• Full-width variants take amounts 0..64.

Construction, validation, and deserialization all enforce this same bound. A value that passes any of them therefore denotes the same shift everywhere.

pub fn apply(self, word: Word, amount: usize) -> Word

Applies this shift to a 64-bit word and returns the result.

The variant selects which word-level operation runs. Full-width variants act on the whole 64-bit word. The 32-bit variants act on the upper and lower halves independently.

Arguments

• The word to shift.
• The shift amount in bits.

Trait Implementations

impl Clone for ShiftVariant

fn clone(&self) -> ShiftVariant

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ShiftVariant

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

Formats the value using the given formatter.

impl DeserializeBytes for ShiftVariant

fn deserialize(read_buf: impl Buf) -> Result<Self, SerializationError>

where Self: Sized,

impl Hash for ShiftVariant

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 Ord for ShiftVariant

fn cmp(&self, other: &ShiftVariant) -> 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 ShiftVariant

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

fn partial_cmp(&self, other: &ShiftVariant) -> 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 SerializeBytes for ShiftVariant

fn serialize(&self, write_buf: impl BufMut) -> Result<(), SerializationError>

impl Copy for ShiftVariant

impl Eq for ShiftVariant

impl StructuralPartialEq for ShiftVariant