Struct KxSnRef 

pub struct KxSnRef<'a> { /* private fields */ }

Zero-copy view over the k elements of a KxSn array (each element is a 2-byte, byte-order-dependent length prefix followed by the payload).

Elements are decoded with the same rule as SnRef::as_str and can be iterated directly:

use rust_stdf::{ByteOrder, KxSnRef};

let raw = [2, 0, b'A', b'B', 2, 0, b'C', b'D']; // two elements: "AB", "CD"
let kx = KxSnRef::new(&raw, 0, 2, ByteOrder::LittleEndian);
for s in &kx {
    println!("{s}");
}

Implementations

impl<'a> KxSnRef<'a>

pub fn new(raw: &'a [u8], start: usize, k: usize, order: ByteOrder) -> Self

Construct a view over k elements starting at byte offset start, using order for the 2-byte length prefixes.

Normally obtained from a generated *View getter; only needed when parsing a known raw layout directly.

pub fn len(&self) -> usize

Number of string elements in the array.

pub fn is_empty(&self) -> bool

true when the array has no elements.

pub fn get_str(&self, i: usize) -> Option<Cow<'a, str>>

Decoded i-th element; None when i is out of range.

Valid UTF-8 payloads are borrowed zero-copy; other payloads are decoded byte → char (Latin-1) into an owned String.

pub fn get_bytes(&self, i: usize) -> Option<&'a [u8]>

Raw payload bytes of the i-th element (without the length prefix); None when i is out of range.

pub fn iter(&self) -> KxSnRefIter<'a>

Iterator over the decoded elements, one pass.

pub fn as_vec(&self) -> Vec<Cow<'a, str>>

Allocating; collects all elements into Vec<Cow<'a, str>>.

pub fn to_owned(&self) -> KxSn

Allocating; reproduces the owned KxSn (Vec<String>), matching the eager parser.

Trait Implementations

impl<'a> Clone for KxSnRef<'a>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for KxSnRef<'a>

impl<'a> Default for KxSnRef<'a>

fn default() -> Self

Return KxSnRef { raw: Default::default(), start: Default::default(), k: Default::default(), order: ByteOrder :: LittleEndian }

impl<'a> IntoIterator for &'a KxSnRef<'a>

type Item = Cow<'a, str>

The type of the elements being iterated over.

type IntoIter = KxSnRefIter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.