Types

The sz module exposes a handful of public value types used throughout the API.

• Byteset — a 256-bit set of bytes used by the byteset search and replace functions.
• IndexSpan — a { offset, length } byte span, returned by uncased match iterators.
• Hasher — an incremental AES-based 64-bit hasher implementing core::hash::Hasher.
• Sha256 — an incremental SHA-256 hasher with a one-shot convenience constructor.
• BuildSzHasher — a std::hash::BuildHasher, gated on feature std, for using Hasher with HashMap/HashSet.
• Utf8View, Utf8Runes, Utf8SplitNewlines, Utf8SplitWhitespaces, Utf8Wordbreaks, Utf8Graphemes, Utf8Sentences, Utf8Linebreaks — lazy UTF-8 views and iterators.
• Utf8UncasedNeedle, Utf8UncasedMatches, NormalForm — uncased search and Unicode normalization helpers.
• SemVer, Status — version and error types.
• Capability, Capabilities — one CPU or GPU capability, and a set of them printed as their names, with the producers that report a device’s set by its ordinal.
• Stream, Scope — a stream of one device, which every engine, conversion and allocator takes, and the span its engine verbs queue in before one join.
• StringsView, StringsIter — a borrowed column, an Arrow tape or slices read in place, which every engine verb and conversion reads.
• Strings, UnifiedAllocator — an owned column in any Allocator, and the memory the host and a GPU both address.
• EscapeKind, SplitKind, StringsError — the formats a column escapes for, whether a split ends a part at every delimiter or every run of them, and the first malformed string unescaping or UTF-8 validation stopped at.
• ArgsortOptions — knobs for sorting.

Status is the error of every fallible call: one variant per failure code of C’s sz_status_t, plus Unrecognized for a code this crate’s header does not list. Success has no variant, being the Ok side of the Result, and Status implements Display and core::error::Error. A buffer of the wrong length is reported as Status::UnexpectedDimensions rather than asserted.

Byteset is constructed from bytes and supports inversion, useful for “not from” semantics:

use stringzilla::{self as sz, Byteset};

let vowels = Byteset::from("aeiou");
let mut punct = Byteset::new();
punct.add(b',');
punct.add(b'.');
let everything = Byteset::new_ascii();         // all ASCII bytes set
let not_vowels = vowels.inverted();            // leaves `vowels` unchanged
let _ = (everything, not_vowels, punct);

Byteset API: new(), new_ascii(), from_bytes(&[u8]) / From<T: AsRef<[u8]>>, add(u8), invert(&mut self), inverted(&self) -> Byteset.

IndexSpan API: new(offset, length), range() -> Range<usize>, extract<'a>(&self, &'a [u8]) -> Option<&'a [u8]>, end() -> usize, plus public offset and length fields. end saturates rather than overflowing, and extract returns None for a span that runs past the text.

use stringzilla::IndexSpan;

let span = IndexSpan::new(6, 5);
assert_eq!(span.range(), 6..11);
assert_eq!(span.end(), 11);
assert_eq!(span.extract(b"Hello World"), Some(&b"World"[..]));
assert_eq!(span.extract(b"Hello"), None);