Struct SimdScanner 

pub struct SimdScanner { /* private fields */ }

Build-once, scan-many structural scanner.

Caches the needle set as a ByteBitmap (and, on nightly with nightly-simd, broadcast SIMD vectors) so each call to SimdScanner::find_any does no per-call setup work — the classic shape for a scanner used inside a parser hot loop.

On stable Rust this is a thin wrapper around the existing find_any_of / SWAR machinery. On nightly with the nightly-simd Cargo feature it widens to a 32-byte Simd<u8, N> chunk loop using portable SIMD, eliminating the per-byte branch and producing a tight or / to_bitmask / trailing_zeros inner loop. Both paths are bit-for-bit equivalent — exhaustively cross-checked by tests/simd_equivalence.rs.

Examples

use noyalib::simd::SimdScanner;

let scanner = SimdScanner::new(b":-[]{}#\n");
assert_eq!(scanner.find_any(b"name: value"), Some(4));
assert_eq!(scanner.find_any(b"all-clean-text"), Some(3));
assert_eq!(scanner.find_any(b"abcdef"), None);

Implementations

impl SimdScanner

pub fn new(needles: &[u8]) -> Self

Build a scanner from a needle byte set. Duplicate needles are coalesced (set semantics). Needle count beyond 16 falls through to the bitmap-only path on every chunk.

Examples

use noyalib::simd::SimdScanner;
let s = SimdScanner::new(b":-{}");
assert_eq!(s.find_any(b"a-b"), Some(1));

pub fn find_any(&self, haystack: &[u8]) -> Option<usize>

Index of the first byte in haystack that matches any needle.

Returns None when the haystack contains no needle byte.

Examples

use noyalib::simd::SimdScanner;
let s = SimdScanner::new(b":\n#");
assert_eq!(s.find_any(b"a comment # here"), Some(10));
assert_eq!(s.find_any(b"plain"), None);

pub fn structural_bitmask_32(&self, chunk: &[u8; 32]) -> u32

Produce a 32-bit “structural bitmask” for a 32-byte chunk: bit i is set iff chunk[i] is in the scanner’s needle set.

This is the building block of the simdjson-style structural discovery loop — instead of walking the haystack byte by byte and stopping at every delimiter, the caller produces a dense 32-bit bitmask per chunk and walks the bits via trailing_zeros(). Each 1 bit is one delimiter, each 0 bit is one byte the scanner can skip without inspection.

On stable Rust the inner loop is bytewise + bit-set (LLVM auto-vectorises). With the nightly-simd Cargo feature on a nightly toolchain, it widens to a single Simd<u8, 32> chunk + to_bitmask() — one branchless dispatch per 32-byte window.

Pair with StructuralIter to walk every structural byte position in a haystack of arbitrary length; that helper handles the chunk-loop boundary and the partial-chunk tail.

Examples

use noyalib::simd::SimdScanner;
let s = SimdScanner::new(b":-{}\n");

// 32-byte chunk: structural bytes at positions 0, 4, 8, 17.
//                              "  0   4   8        17"
let chunk: [u8; 32] = *b":bcd-fgh:abcdefgh{ijklmnopqrstuv";
let mask = s.structural_bitmask_32(&chunk);
// bits 0, 4, 8, 17 set.
assert_eq!(mask & (1 << 0), 1 << 0);
assert_eq!(mask & (1 << 4), 1 << 4);
assert_eq!(mask & (1 << 8), 1 << 8);
assert_eq!(mask & (1 << 17), 1 << 17);

Trait Implementations

impl Clone for SimdScanner

fn clone(&self) -> SimdScanner

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for SimdScanner

impl Debug for SimdScanner

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

Formats the value using the given formatter.