Enum CharsCowsAuto 

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

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

Returns an enum that can hold any combination of offset/length types.

Variants

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

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

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

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

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

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

Implementations

impl<'a> CharsCowsAuto<'a>

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

where I: IntoIterator + Clone, I::Item: AsRef<str>,

Creates the most memory-efficient CharsCows based on data size and max word length.

Examples

use stringtape::CharsCowsAuto;
use std::borrow::Cow;

let data = "hello world";
let cows = CharsCowsAuto::from_iter_and_data(
    data.split_whitespace(),
    Cow::Borrowed(data.as_bytes())
).unwrap();

// Automatically picks CharsCows<u32, u8> for small data
assert_eq!(cows.len(), 2);

Creates the most memory-efficient CharsCows using a two-pass strategy.

First pass scans to find the maximum word length, then second pass builds with optimal types. Requires Clone iterator for memory efficiency.

Examples

use stringtape::CharsCowsAuto;
use std::borrow::Cow;

let data = "hello world";
let cows = CharsCowsAuto::from_iter_and_data(
    data.split_whitespace(),  // Clone iterator
    Cow::Borrowed(data.as_bytes())
).unwrap();

assert_eq!(cows.len(), 2);

pub fn len(&self) -> usize

Returns the number of cows.

pub fn is_empty(&self) -> bool

Returns true if the collection contains no cows.

pub fn get(&self, index: usize) -> Option<&str>

Returns a reference to the string at the given index.

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

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

Safety

Caller must ensure index < self.len().

pub fn bytes_per_entry(&self) -> usize

Returns the byte size per entry for the selected type combination.

pub fn type_name(&self) -> &'static str

Returns a string describing the selected type combination.

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

Returns an iterator over the string cows.

Examples

use stringtape::CharsCowsAuto;
use std::borrow::Cow;

let data = "hello world foo";
let cows = CharsCowsAuto::from_iter_and_data(
    data.split_whitespace(),
    Cow::Borrowed(data.as_bytes())
).unwrap();

let words: Vec<&str> = cows.iter().collect();
assert_eq!(words, vec!["hello", "world", "foo"]);

pub fn sort(&mut self)

Sorts the slices in-place using the default string comparison.

This is a stable sort that preserves the order of equal elements.

Examples

use stringtape::CharsCowsAuto;
use std::borrow::Cow;

let data = "zebra apple banana";
let mut cows = CharsCowsAuto::from_iter_and_data(
    data.split_whitespace(),
    Cow::Borrowed(data.as_bytes())
).unwrap();

cows.sort();
let sorted: Vec<&str> = cows.iter().collect();
assert_eq!(sorted, vec!["apple", "banana", "zebra"]);

pub fn sort_unstable(&mut self)

Sorts the slices in-place using an unstable sorting algorithm.

This is faster than stable sort but may not preserve the order of equal elements.

pub fn sort_by<F>(&mut self, compare: F)

where F: FnMut(&str, &str) -> Ordering,

Sorts the slices in-place using a custom comparison function.

Examples

use stringtape::CharsCowsAuto;
use std::borrow::Cow;

let data = "aaa bb c";
let mut cows = CharsCowsAuto::from_iter_and_data(
    data.split_whitespace(),
    Cow::Borrowed(data.as_bytes())
).unwrap();

// Sort by length, then alphabetically
cows.sort_by(|a, b| a.len().cmp(&b.len()).then(a.cmp(b)));
let sorted: Vec<&str> = cows.iter().collect();
assert_eq!(sorted, vec!["c", "bb", "aaa"]);

pub fn sort_by_key<K, F>(&mut self, f: F)

where F: FnMut(&str) -> K, K: Ord,

Sorts the slices in-place using a key extraction function.

Examples

use stringtape::CharsCowsAuto;
use std::borrow::Cow;

let data = "aaa bb c";
let mut cows = CharsCowsAuto::from_iter_and_data(
    data.split_whitespace(),
    Cow::Borrowed(data.as_bytes())
).unwrap();

// Sort by string length
cows.sort_by_key(|s| s.len());
let sorted: Vec<&str> = cows.iter().collect();
assert_eq!(sorted, vec!["c", "bb", "aaa"]);

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

Returns a reference to the underlying data buffer.

Examples

use stringtape::CharsCowsAuto;
use std::borrow::Cow;

let data = "hello world";
let cows = CharsCowsAuto::from_iter_and_data(
    data.split_whitespace(),
    Cow::Borrowed(data.as_bytes())
).unwrap();

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

pub fn parent(&self) -> &str

Returns a reference to the parent string that all slices reference.

Examples

use stringtape::CharsCowsAuto;
use std::borrow::Cow;

let data = "hello world";
let cows = CharsCowsAuto::from_iter_and_data(
    data.split_whitespace(),
    Cow::Borrowed(data.as_bytes())
).unwrap();

assert_eq!(cows.parent(), "hello world");

pub fn as_bytes(&self) -> BytesCowsAuto<'_>

Returns a zero-copy view of this CharsCowsAuto as a BytesCowsAuto.

This is a no-cost operation that reinterprets the string collection as bytes without copying or moving any data.

Examples

use stringtape::CharsCowsAuto;
use std::borrow::Cow;

let data = "hello world";
let cows = CharsCowsAuto::from_iter_and_data(
    data.split_whitespace(),
    Cow::Borrowed(data.as_bytes())
).unwrap();

let bytes = cows.as_bytes();
assert_eq!(bytes.get(0), Some(&b"hello"[..]));
assert_eq!(bytes.get(1), Some(&b"world"[..]));

Trait Implementations

impl<'a> Debug for CharsCowsAuto<'a>

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

Formats the value using the given formatter.

impl<'a> Hash for CharsCowsAuto<'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 CharsCowsAuto<'a>

type Item = &'a str

The type of the elements being iterated over.

type IntoIter = CharsCowsAutoIter<'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 CharsCowsAuto<'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 CharsCowsAuto<'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 CharsCowsAuto<'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 CharsCowsAuto<'a>