Struct Lanes16Word8 

#[repr(C, align(16))]
pub struct Lanes16Word8(pub [u8; 16]);

Sixteen Word8 lanes = one 128-bit register (__m128i) — the BYTE-SHUFFLE carrier for SIMD text codecs (hex encode/decode). Its vocabulary is shuffle (pshufb, a 16-entry byte LUT), byte AND, per-byte shift, and the two byte interleaves — so a hex codec WRITTEN in Logos over it compiles to the pshufb sequence (AOT, when SSSE3 is statically enabled) and runs the byte-identical scalar spec on the interpreter. Lane i is byte i (index 0 low), matching _mm_loadu_si128.

Tuple Fields

0: [u8; 16]

Implementations

impl Lanes16Word8

pub const LANES: usize = 16

The number of lanes.

pub const fn splat(x: u8) -> Self

Broadcast one byte into all sixteen lanes.

pub fn from_bytes(s: &[u8]) -> Self

Pack the first sixteen bytes of a slice (shorter slices zero-fill).

pub fn to_bytes(self) -> [u8; 16]

The sixteen lane bytes.

pub fn lane(self, i: usize) -> u8

Lane i (0-based).

pub fn shuffle(self, idx: Self) -> Self

Byte shuffle (pshufb): out[i] = if idx[i] & 0x80 { 0 } else { self[idx[i] & 0x0f] } — a 16-entry byte lookup, the core of SIMD hex codecs (nibble → hex char; hyphen strip).

pub fn bitand(self, o: Self) -> Self

Lane-wise AND (_mm_and_si128) — the low-nibble mask; auto-vectorizes to pand.

pub fn shr_bytes(self, n: u32) -> Self

Per-byte logical shift right by n — the high-nibble extract (v >> 4).

pub fn interleave_lo(self, o: Self) -> Self

Interleave the low eight bytes (_mm_unpacklo_epi8): [a0,b0,a1,b1,…,a7,b7].

pub fn interleave_hi(self, o: Self) -> Self

Interleave the high eight bytes (_mm_unpackhi_epi8): [a8,b8,…,a15,b15].

pub fn byte_add(self, o: Self) -> Self

Per-byte wrapping add (_mm_add_epi8) — the ASCII→nibble decode (lo + 9·hibit).

pub fn maddubs(self, o: Self) -> Self

Multiply-add adjacent byte pairs (pmaddubsw): self unsigned × o signed, summing pairs into eight saturating i16 lanes stored little-endian. Weights [16,1,…] fuse each nibble pair into the decoded byte (hex parse). Result carries 8 u16 in its 16 bytes; narrow with packus.

pub fn packus(self, o: Self) -> Self

Pack two 8×i16 vectors to 16×u8 with unsigned saturation (packuswb): self’s eight 16-bit lanes → bytes 0–7, o’s → bytes 8–15. Narrows the maddubs output back to bytes.

Trait Implementations

impl BitAnd for Lanes16Word8

type Output = Lanes16Word8

The resulting type after applying the & operator.

fn bitand(self, o: Self) -> Self

Performs the & operation.

impl Clone for Lanes16Word8

fn clone(&self) -> Lanes16Word8

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Lanes16Word8

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

Formats the value using the given formatter.

impl Hash for Lanes16Word8

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 PartialEq for Lanes16Word8

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

impl Eq for Lanes16Word8

impl StructuralPartialEq for Lanes16Word8