Struct Span 

pub struct Span<'a> {
    pub content: Cow<'a, str>,
    pub style: Style,
}

A string where all graphemes have the same style.

Fields

content: Cow<'a, str>

style: Style

Implementations

impl<'a> Span<'a>

pub fn raw<T>(content: T) -> Span<'a>

where T: Into<Cow<'a, str>>,

Create a span with no style.

Examples

Span::raw("My text");
Span::raw(String::from("My text"));

pub fn styled<T>(content: T, style: Style) -> Span<'a>

where T: Into<Cow<'a, str>>,

Create a span with a style.

Examples

let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
Span::styled("My text", style);
Span::styled(String::from("My text"), style);

pub fn width(&self) -> usize

Returns the width of the content held by this span.

pub fn styled_graphemes( &'a self, base_style: Style, ) -> impl Iterator<Item = StyledGrapheme<'a>>

Returns an iterator over the graphemes held by this span.

base_style is the Style that will be patched with each grapheme Style to get the resulting Style.

Examples

let style = Style::default().fg(Color::Yellow);
let span = Span::styled("Text", style);
let style = Style::default().fg(Color::Green).bg(Color::Black);
let styled_graphemes = span.styled_graphemes(style);
assert_eq!(
    vec![
        StyledGrapheme {
            symbol: "T",
            style: Style {
                fg: Some(Color::Yellow),
                bg: Some(Color::Black),
                add_modifier: Modifier::empty(),
                sub_modifier: Modifier::empty(),
            },
        },
        StyledGrapheme {
            symbol: "e",
            style: Style {
                fg: Some(Color::Yellow),
                bg: Some(Color::Black),
                add_modifier: Modifier::empty(),
                sub_modifier: Modifier::empty(),
            },
        },
        StyledGrapheme {
            symbol: "x",
            style: Style {
                fg: Some(Color::Yellow),
                bg: Some(Color::Black),
                add_modifier: Modifier::empty(),
                sub_modifier: Modifier::empty(),
            },
        },
        StyledGrapheme {
            symbol: "t",
            style: Style {
                fg: Some(Color::Yellow),
                bg: Some(Color::Black),
                add_modifier: Modifier::empty(),
                sub_modifier: Modifier::empty(),
            },
        },
    ],
    styled_graphemes.collect::<Vec<StyledGrapheme>>()
);

Trait Implementations

impl<'a> Clone for Span<'a>

fn clone(&self) -> Span<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Span<'a>

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

Formats the value using the given formatter.

impl<'a> From<&'a str> for Span<'a>

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

Converts to this type from the input type.

impl<'a> From<Span<'a>> for Spans<'a>

fn from(span: Span<'a>) -> Spans<'a>

Converts to this type from the input type.

impl<'a> From<Span<'a>> for Text<'a>

fn from(span: Span<'a>) -> Text<'a>

Converts to this type from the input type.

impl<'a> From<String> for Span<'a>

fn from(s: String) -> Span<'a>

Converts to this type from the input type.

impl<'a> PartialEq for Span<'a>

fn eq(&self, other: &Span<'a>) -> 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> StructuralPartialEq for Span<'a>