Struct StyledString 

pub struct StyledString<T = String> { /* private fields */ }

Heap-allocated styled string.

StyledString represents the owned string variant in contrast to StyledStr, which is borrowed. Since conversion to a StyledStr is cheap, some immutable methods are accessible via StyledStr only (e.g., iterating over style spans or splitting a string). This allows to define these methods as const fns and/or to propagate the borrowed data lifetime correctly.

A StyledString can be parsed from rich syntax via the FromStr trait, from a string with ANSI escapes via StyledString::from_ansi(), or manually constructed via StyledStringBuilder.

Implementations

impl<T> StyledString<T>

where T: Deref<Target = str>,

pub fn into_text(self) -> T

Returns the unstyled text behind this string.

pub fn as_str(&self) -> StyledStr<'_>

Borrows a StyledStr from this string. This can be used to call more complex methods.

pub fn text(&self) -> &str

Returns the unstyled text.

impl StyledString

pub fn builder() -> StyledStringBuilder

Creates a builder for styled strings.

pub fn from_ansi(ansi_str: &str) -> Result<Self, AnsiError>

Parses a string from a string with embedded ANSI escape sequences.

Errors

Returns an error if the input is not a valid ANSI escaped string.

Examples

let str = StyledString::from_ansi(
    "\u{1b}[1;32mHello,\u{1b}[m world\u{1b}[3m!\u{1b}[m",
)?;
assert_eq!(str, styled!("[[bold green]]Hello,[[/]] world[[it]]!"));

pub fn from_ansi_bytes(ansi_bytes: &[u8]) -> Result<Self, AnsiError>

Parses a string from bytes with embedded ANSI escape sequences. This is similar to Self::from_ansi(), just using bytes as an input.

Errors

Returns an error if the input is not a valid ANSI escaped string.

pub fn push_str(&mut self, other: StyledStr<'_>)

Pushes another styled string at the end of this one.

Use StyledStringBuilder for more complex string manipulations.

Examples

let mut styled = styled!("[[bold green!]]Hello").to_owned();
styled.push_str(styled!("[[it]]!"));
// `push_str()` is also available via `+=` operator:
styled += styled!("[[it]]❤");

assert_eq!(
    styled,
    styled!("[[bold green!]]Hello[[it]]!❤")
);

pub fn pop(&mut self) -> Option<(char, Style)>

Pops a single char from the end of the string.

Examples

let mut styled = styled!("[[bold green!]]Hello[[it]]!❤").to_owned();
let (ch, style) = styled.pop().unwrap();
assert_eq!(ch, '❤');
assert_eq!(style, Style::new().italic());
assert_eq!(styled, styled!("[[bold green!]]Hello[[it]]!"));

styled.pop().unwrap();
assert_eq!(styled, styled!("[[bold green!]]Hello"));

Trait Implementations

impl AddAssign<StyledStr<'_>> for StyledString

fn add_assign(&mut self, rhs: StyledStr<'_>)

Performs the += operation.

impl<T: Clone> Clone for StyledString<T>

fn clone(&self) -> StyledString<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for StyledString<T>

where T: Deref<Target = str>,

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

Formats the value using the given formatter.

impl<T: Default> Default for StyledString<T>

fn default() -> StyledString<T>

Returns the “default value” for a type.

impl<T> Display for StyledString<T>

where T: Deref<Target = str>,

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

Formats the value using the given formatter.

impl<'a> Extend<StyledStr<'a>> for StyledString

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

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, T> From<StyledStr<'a>> for StyledString<T>

where T: From<&'a str> + Deref<Target = str>,

fn from(str: StyledStr<'a>) -> Self

Converts to this type from the input type.

impl From<StyledString> for StyledStringBuilder

fn from(string: StyledString) -> Self

Converts to this type from the input type.

impl<'a> FromIterator<StyledStr<'a>> for StyledString

fn from_iter<I: IntoIterator<Item = StyledStr<'a>>>(iter: I) -> Self

Creates a value from an iterator.

impl FromStr for StyledString

type Err = ParseError

The associated error which can be returned from parsing.

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

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

impl<T: PartialEq> PartialEq for StyledString<T>

fn eq(&self, other: &StyledString<T>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T> PartialEq<StyledStr<'_>> for StyledString<T>

where T: Deref<Target = str>,

fn eq(&self, other: &StyledStr<'_>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T> PartialEq<StyledString<T>> for StyledStr<'_>

where T: Deref<Target = str>,

fn eq(&self, other: &StyledString<T>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<T: PartialEq> StructuralPartialEq for StyledString<T>