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 unsafe fn get_unchecked(&self, index: usize) -> &[u8]

Returns a reference to the bytes at the given index without bounds checking.

Safety

Caller must ensure index < self.len().

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 data(&self) -> &[u8]

Returns a reference to the underlying data buffer.

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();

assert_eq!(bytes.data(), b"hello world");

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

Returns a reference to the parent byte buffer that all slices reference.

This is an alias for data() that provides a consistent API across all Cows types.

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();

assert_eq!(bytes.parent(), b"hello 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> Debug for BytesCowsAuto<'a>

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

Formats the value using the given formatter.

impl<'a> Hash for BytesCowsAuto<'a>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

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.

impl<'a> Ord for BytesCowsAuto<'a>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a> PartialEq for BytesCowsAuto<'a>

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialOrd for BytesCowsAuto<'a>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> Eq for BytesCowsAuto<'a>