Enum BytesCowsAuto 

pub enum BytesCowsAuto<'a> {
    U32U8(BytesCows<'a, u32, u8>),
    U32U16(BytesCows<'a, u32, u16>),
    U32U32(BytesCows<'a, u32, u32>),
    U64U8(BytesCows<'a, u64, u8>),
    U64U16(BytesCows<'a, u64, u16>),
    U64U32(BytesCows<'a, u64, u32>),
}

Automatically selects the most memory-efficient BytesCows type based on data size.

Variants

U32U8(BytesCows<'a, u32, u8>)

U32U16(BytesCows<'a, u32, u16>)

U32U32(BytesCows<'a, u32, u32>)

U64U8(BytesCows<'a, u64, u8>)

U64U16(BytesCows<'a, u64, u16>)

U64U32(BytesCows<'a, u64, u32>)

Implementations

impl<'a> BytesCowsAuto<'a>

pub fn from_iter_and_data<I>( iter: I, data: Cow<'a, [u8]>, ) -> Result<Self, StringTapeError>

where I: IntoIterator + Clone, I::Item: AsRef<[u8]>,

Creates BytesCowsAuto from iterator of byte cows. Auto-selects offset and length types based on data size and max slice length.

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

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

pub fn as_chars(&self) -> Result<CharsCowsAuto<'_>, StringTapeError>

Returns a zero-copy view of this BytesCowsAuto as a CharsCowsAuto if all slices are valid UTF-8.

This validates that all byte slices contain valid UTF-8, then reinterprets the collection as strings without copying or moving any data.

Errors

Returns StringTapeError::Utf8Error if any slice contains invalid UTF-8.

Examples

use stringtape::BytesCowsAuto;
use std::borrow::Cow;

let data = b"hello world";
let bytes = BytesCowsAuto::from_iter_and_data(
    data.split(|&b| b == b' '),
    Cow::Borrowed(&data[..])
).unwrap();

let chars = bytes.as_chars().unwrap();
assert_eq!(chars.get(0), Some("hello"));
assert_eq!(chars.get(1), Some("world"));

pub fn iter(&self) -> BytesCowsAutoIter<'_>

Returns an iterator over the byte cows.

Examples

use stringtape::BytesCowsAuto;
use std::borrow::Cow;

let data = b"hello world foo";
let bytes = BytesCowsAuto::from_iter_and_data(
    data.split(|&b| b == b' '),
    Cow::Borrowed(&data[..])
).unwrap();

let slices: Vec<&[u8]> = bytes.iter().collect();
assert_eq!(slices, vec![&b"hello"[..], &b"world"[..], &b"foo"[..]]);

Trait Implementations

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

type Item = &'a [u8]

The type of the elements being iterated over.

type IntoIter = BytesCowsAutoIter<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.