Type Alias Str

pub type Str = StrInner<Bytes>;

An immutable variant of Bytes-backed string.

The methods and their documentation are on StrInner, but users are mostly expected to use this and the StrMut aliases.

Aliased Type

struct Str(/* private fields */);

Implementations

impl Str

pub fn slice<R>(&self, range: R) -> Str

where str: Index<R, Output = str>,

Extracts a subslice of the string as an owned Str.

Panics

If the byte indices in the range are not on char boundaries.

pub fn slice_ref(&self, subslice: &str) -> Self

Extracts owned representation of the slice passed.

This method accepts a string sub-slice of self. It then extracts the slice but as the Str type. This makes it easier to use “ordinary” string parsing/manipulation and then go back to holding the Bytes-based representation.

This is zero-copy, the common part will be shared by reference counting.

Panics

If the provided slice is not a sub-slice of self. This is checked based on address of the slice, not on the content.

Example

let owned = Str::from("Hello World");
let borrowed_mid: &str = &owned[2..5];

let mid: Str = owned.slice_ref(borrowed_mid);
assert_eq!("Hello World", owned);
assert_eq!("llo", mid);

pub const fn from_static(s: &'static str) -> Self

Create Str from static string in O(1).

impl<S: Storage> StrInner<S>

pub fn new() -> Self

Creates an empty instance.

pub fn into_inner(self) -> S

Extracts the inner byte storage.

pub fn inner(&self) -> &S

Access to the inner storage.

pub fn from_inner(s: S) -> Result<Self, Utf8Error<S>>

Creates an instance from an existing byte storage.

It may fail if the content is not valid UTF8.

A try_from may be used instead.

pub const unsafe fn from_inner_unchecked(s: S) -> Self

Same as from_inner, but without the checks.

Safety

The caller must ensure content is valid UTF8.

pub fn split_at_bytes(self, at: usize) -> (Self, Self)

Splits the string into two at the given index.

Panics

If the index is not at char boundary.

pub fn split_whitespace_bytes(self) -> impl Iterator<Item = Self>

Splits into whitespace separated “words”.

This acts like split_whitespace, but yields owned instances. It doesn’t clone the content, it just increments some reference counts.

pub fn split_ascii_whitespace_bytes(self) -> impl Iterator<Item = Self>

Splits into whitespace separated “words”.

This acts like split_ascii_whitespace, but yields owned instances. This doesn’t clone the content, it just increments some reference counts.

pub fn lines_bytes(self) -> impl Iterator<Item = Self>

Splits into lines.

This acts like lines, but yields owned instances. The content is not cloned, this just increments some reference counts.

pub fn split_bytes<'s>(self, sep: &'s str) -> impl Iterator<Item = Self> + 's

where S: 's,

Splits with the provided separator.

This acts somewhat like split, but yields owned instances. Also, it accepts only string patters (since the Pattern is not stable ☹). The content is not cloned, this just increments some reference counts.

pub fn splitn_bytes<'s>( self, n: usize, sep: &'s str, ) -> impl Iterator<Item = Self> + 's

where S: 's,

Splits max. n times according to the given pattern.

This acts somewhat like splitn, but yields owned instances. Also, it accepts only string patters (since the Pattern is not stable ☹). The content is not cloned, this just increments some reference counts.

pub fn rsplit_bytes<'s>(self, sep: &'s str) -> impl Iterator<Item = Self> + 's

where S: 's,

A reverse version of split_bytes.

pub fn rsplitn_bytes<'s>( self, n: usize, sep: &'s str, ) -> impl Iterator<Item = Self> + 's

where S: 's,

A reverse version of splitn_bytes.

impl<S: StorageMut> StrInner<S>

pub fn push_str(&mut self, s: &str)

Appends a string.

pub fn push(&mut self, c: char)

Appends one character.

pub unsafe fn inner_mut(&mut self) -> &mut S

Provides mutable access to the inner buffer.

Safety

The caller must ensure that the content stays valid UTF8.

pub fn freeze(self) -> StrInner<S::Immutable>

Turns the mutable variant into an immutable one.

The advantage is that it can then be shared (also by small parts).

Trait Implementations

impl From<Box<str>> for Str

fn from(s: Box<str>) -> Self

Converts to this type from the input type.

impl From<StrInner<BytesMut>> for Str

fn from(s: StrMut) -> Self

Converts to this type from the input type.

impl From<String> for Str

fn from(s: String) -> Self

Converts to this type from the input type.

impl<S: StorageMut> Add<&str> for StrInner<S>

type Output = StrInner<S>

The resulting type after applying the + operator.

fn add(self, rhs: &str) -> Self::Output

Performs the + operation.

impl<S: StorageMut> AddAssign<&str> for StrInner<S>

fn add_assign(&mut self, rhs: &str)

Performs the += operation.

impl<S: StorageMut> AsMut<str> for StrInner<S>

fn as_mut(&mut self) -> &mut str

Converts this type into a mutable reference of the (usually inferred) input type.

impl<S, T> AsRef<T> for StrInner<S>

where S: Storage, str: AsRef<T>,

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<S: Storage> Borrow<str> for StrInner<S>

fn borrow(&self) -> &str

Immutably borrows from an owned value.

impl<S: StorageMut> BorrowMut<str> for StrInner<S>

fn borrow_mut(&mut self) -> &mut str

Mutably borrows from an owned value.

impl<S: Clone> Clone for StrInner<S>

fn clone(&self) -> StrInner<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Storage> Debug for StrInner<S>

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

Formats the value using the given formatter.

impl<S: Default> Default for StrInner<S>

fn default() -> StrInner<S>

Returns the “default value” for a type.

impl<S: Storage> Deref for StrInner<S>

type Target = str

The resulting type after dereferencing.

fn deref(&self) -> &str

Dereferences the value.

impl<S: StorageMut> DerefMut for StrInner<S>

fn deref_mut(&mut self) -> &mut str

Mutably dereferences the value.

impl<S: Storage> Display for StrInner<S>

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

Formats the value using the given formatter.

impl<'a, S: StorageMut> Extend<&'a String> for StrInner<S>

fn extend<T: IntoIterator<Item = &'a String>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, S: StorageMut> Extend<&'a char> for StrInner<S>

fn extend<T: IntoIterator<Item = &'a char>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, S: StorageMut> Extend<&'a str> for StrInner<S>

fn extend<T: IntoIterator<Item = &'a str>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<S: StorageMut> Extend<Box<str>> for StrInner<S>

fn extend<T: IntoIterator<Item = Box<str>>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, S: StorageMut> Extend<Cow<'a, str>> for StrInner<S>

fn extend<T: IntoIterator<Item = Cow<'a, str>>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<S: StorageMut> Extend<String> for StrInner<S>

fn extend<T: IntoIterator<Item = String>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<S: StorageMut> Extend<char> for StrInner<S>

fn extend<T: IntoIterator<Item = char>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, S> From<&'a String> for StrInner<S>

where S: Storage,

fn from(s: &'a String) -> Self

Converts to this type from the input type.

impl<'a, S> From<&'a str> for StrInner<S>

where S: Storage,

fn from(s: &'a str) -> Self

Converts to this type from the input type.

impl<'a, S> From<Cow<'a, str>> for StrInner<S>

where S: Storage,

fn from(s: Cow<'a, str>) -> Self

Converts to this type from the input type.

impl<'a, S> FromIterator<&'a String> for StrInner<S>

where S: Storage,

fn from_iter<T: IntoIterator<Item = &'a String>>(iter: T) -> Self

Creates a value from an iterator.

impl<'a, S> FromIterator<&'a str> for StrInner<S>

where S: Storage,

fn from_iter<T: IntoIterator<Item = &'a str>>(iter: T) -> Self

Creates a value from an iterator.

impl<S> FromIterator<Box<str>> for StrInner<S>

where S: Storage,

fn from_iter<T: IntoIterator<Item = Box<str>>>(iter: T) -> Self

Creates a value from an iterator.

impl<'a, S> FromIterator<Cow<'a, str>> for StrInner<S>

where S: Storage,

fn from_iter<T: IntoIterator<Item = Cow<'a, str>>>(iter: T) -> Self

Creates a value from an iterator.

impl<S> FromIterator<String> for StrInner<S>

where S: Storage,

fn from_iter<T: IntoIterator<Item = String>>(iter: T) -> Self

Creates a value from an iterator.

impl<S: Storage> FromStr for StrInner<S>

type Err = Infallible

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<S: Storage> Hash for StrInner<S>

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<S, I> Index<I> for StrInner<S>

where S: Storage, str: Index<I>,

type Output = <str as Index<I>>::Output

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<S, I> IndexMut<I> for StrInner<S>

where S: StorageMut, str: IndexMut<I>,

fn index_mut(&mut self, index: I) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<S: Storage> Ord for StrInner<S>

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, S: Storage> PartialEq<&'a mut str> for StrInner<S>

fn eq(&self, other: &&'a mut str) -> 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, S: Storage> PartialEq<&'a str> for StrInner<S>

fn eq(&self, other: &&'a str) -> 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<S: Storage> PartialEq<Box<str>> for StrInner<S>

fn eq(&self, other: &Box<str>) -> 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, S: Storage> PartialEq<Cow<'a, str>> for StrInner<S>

fn eq(&self, other: &Cow<'a, str>) -> 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<S: Storage> PartialEq<String> for StrInner<S>

fn eq(&self, other: &String) -> 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<S: Storage> PartialEq for StrInner<S>

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, S: Storage> PartialOrd<&'a mut str> for StrInner<S>

fn partial_cmp(&self, other: &&'a mut str) -> 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, S: Storage> PartialOrd<&'a str> for StrInner<S>

fn partial_cmp(&self, other: &&'a str) -> 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<S: Storage> PartialOrd<Box<str>> for StrInner<S>

fn partial_cmp(&self, other: &Box<str>) -> 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, S: Storage> PartialOrd<Cow<'a, str>> for StrInner<S>

fn partial_cmp(&self, other: &Cow<'a, str>) -> 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<S: Storage> PartialOrd<String> for StrInner<S>

fn partial_cmp(&self, other: &String) -> 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<S: Storage> PartialOrd for StrInner<S>

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 TryFrom<Bytes> for StrInner<Bytes>

type Error = Utf8Error<Bytes>

The type returned in the event of a conversion error.

fn try_from(s: Bytes) -> Result<Self, Utf8Error<Bytes>>

Performs the conversion.

impl<S: StorageMut> Write for StrInner<S>

fn write_str(&mut self, s: &str) -> FmtResult

Writes a string slice into this writer, returning whether the write succeeded.

fn write_char(&mut self, c: char) -> Result<(), Error>

Writes a char into this writer, returning whether the write succeeded.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Glue for usage of the write! macro with implementors of this trait.

impl<S: Storage> Eq for StrInner<S>