Struct StrBuffer 

pub struct StrBuffer { /* private fields */ }

A contiguous UTF-8 string column buffer (Arrow LargeUtf8: i64 offsets).

Implementations

impl StrBuffer

pub fn from_vec(v: Vec<String>) -> Self

Build from owned Strings.

Examples found in repository

examples/asm_probe_string.rs (line 16)

fn main() {
    let sb = StrBuffer::from_vec(vec!["ab".into(), "cd".into(), "ef".into()]);
    println!("{}", probe_str_eq_scan(black_box(&sb), black_box("cd")));
}

pub fn from_buffers(offsets: Buffer<i64>, data: Buffer<u8>) -> Self

Zero-copy from foreign Arrow LargeUtf8 buffers (offsets + data + their guard).

pub fn buffers(&self) -> (&Buffer<i64>, &Buffer<u8>)

The raw offset / data buffers (for a zero-copy Arrow export).

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn get(&self, i: usize) -> &str

Cell i as &str (a borrow into the data buffer). Bounds-checked.

pub unsafe fn get_unchecked(&self, i: usize) -> &str

Cell i as &str, without bounds checks — the zero-overhead accessor for the internal hot kernels (compare / sort / scan), mirroring arrow-rs GenericStringArray::value_unchecked.

Safety

i < self.len(). The offsets are a structural invariant — monotonic with offsets[len] == data.len() — so i < len makes both offset reads and the [s..e] data span in bounds; only the redundant checks are elided.

pub fn iter(&self) -> impl Iterator<Item = &str> + '_

Iterate the cells as &str. The two backing slices are resolved once (a single Buffer match each, hoisted out of the walk), then indexed without bounds checks — so a sequential scan is one tight loop, matching a &[String] walk with no per-element overhead.

Examples found in repository

examples/asm_probe_string.rs (line 12)

pub fn probe_str_eq_scan(s: &StrBuffer, target: &str) -> usize {
    s.iter().filter(|&x| x == target).count()
}

pub fn to_vec(&self) -> Vec<String>

Materialize owned Strings (only where a Vec<String> is genuinely needed).

pub fn slice(&self, start: usize, end: usize) -> StrBuffer

A contiguous sub-range [start, end) as a fresh StrBuffer (re-packs the bytes; Buffer borrowing of a sub-span is a future refinement).

pub fn extend<S: AsRef<str>>(&mut self, items: impl IntoIterator<Item = S>)

Append the cells of items in place — the offset and data buffers grow via copy-on-write rather than being rebuilt, so a live row-by-row append stays amortised O(1) per cell instead of O(n) (which made repeated append O(n²)). A borrowed (or shared) buffer materialises once on the first append.

Trait Implementations

impl Clone for StrBuffer

fn clone(&self) -> StrBuffer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StrBuffer

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

Formats the value using the given formatter.

impl<S: AsRef<str>> FromIterator<S> for StrBuffer

fn from_iter<I: IntoIterator<Item = S>>(it: I) -> Self

The single construction path: concatenate the cells’ UTF-8 into one data buffer, recording the running byte boundary in offsets (n + 1 entries).

impl PartialEq for StrBuffer

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.