Struct BytesCows 

pub struct BytesCows<'a, Offset: OffsetType = u32, Length: LengthType = u16> { /* private fields */ }

A memory-efficient collection of byte slices with configurable offset and length types.

Similar to CharsCows but for arbitrary binary data without UTF-8 validation.

Implementations

impl<'a, Offset: OffsetType, Length: LengthType> BytesCows<'a, Offset, Length>

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

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

Creates BytesCows from iterator of byte slices and shared data buffer.

Slices must be subslices of the data buffer. Offsets and lengths are inferred from slice pointers.

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

where I: IntoIterator<Item = (usize, usize)>,

Creates BytesCows from iterator of (offset, length) pairs and data buffer.

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

Returns a reference to the bytes at the given index, or None if out of bounds.

pub fn len(&self) -> usize

Returns the number of slices in the collection.

pub fn is_empty(&self) -> bool

Returns true if the collection contains no cows.

pub fn iter(&self) -> BytesCowsIter<'_, Offset, Length>

Returns an iterator over the byte cows.

pub fn data(&self) -> &[u8]

Returns a reference to the underlying data buffer.

pub fn as_chars(&self) -> Result<CharsCows<'_, Offset, Length>, StringTapeError>

Returns a zero-copy view of this BytesCows as a CharsCows 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::BytesCowsU32U8;
use std::borrow::Cow;

let data = b"hello world";
let bytes = BytesCowsU32U8::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"));

impl<'a, Offset: OffsetType, Length: LengthType> BytesCows<'a, Offset, Length>

pub fn try_into_chars_slices( self, ) -> Result<CharsCows<'a, Offset, Length>, StringTapeError>

Trait Implementations

impl<'a, Offset: Clone + OffsetType, Length: Clone + LengthType> Clone for BytesCows<'a, Offset, Length>

fn clone(&self) -> BytesCows<'a, Offset, Length>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, Offset: Debug + OffsetType, Length: Debug + LengthType> Debug for BytesCows<'a, Offset, Length>

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

Formats the value using the given formatter.

impl<'a, Offset: OffsetType, Length: LengthType> From<CharsCows<'a, Offset, Length>> for BytesCows<'a, Offset, Length>

fn from(chars_slices: CharsCows<'a, Offset, Length>) -> Self

Converts to this type from the input type.

impl<'a, Offset: OffsetType, Length: LengthType> Index<usize> for BytesCows<'a, Offset, Length>

type Output = [u8]

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, Offset: OffsetType, Length: LengthType> IntoIterator for &'a BytesCows<'a, Offset, Length>

type Item = &'a [u8]

The type of the elements being iterated over.

type IntoIter = BytesCowsIter<'a, Offset, Length>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, Offset: OffsetType, Length: LengthType> TryFrom<BytesCows<'a, Offset, Length>> for CharsCows<'a, Offset, Length>

type Error = StringTapeError

The type returned in the event of a conversion error.

fn try_from( bytes_slices: BytesCows<'a, Offset, Length>, ) -> Result<Self, Self::Error>

Performs the conversion.