Struct SpannedString

pub struct SpannedString<T> { /* private fields */ }

A string with associated spans.

Each span has an associated attribute T.

Implementations

impl SpannedString<Style>

pub fn plain<S>(content: S) -> Self

where S: Into<String>,

Returns a plain StyledString without any style.

You got no style, Dutch. You know that.

pub fn styled<S, T>(content: S, style: T) -> Self

where S: Into<String>, T: Into<Style>,

Creates a new StyledString using a single style for the entire text.

pub fn append_plain<S>(&mut self, text: S)

where S: Into<String>,

Appends the given plain text to self.

pub fn append_styled<S, T>(&mut self, text: S, style: T)

where S: Into<String>, T: Into<Style>,

Appends text to self, using style.

impl SpannedString<()>

pub fn plain<S>(content: S) -> Self

where S: Into<String>,

Returns a simple spanned string without any attribute.

impl<T> SpannedString<T>

pub fn new() -> Self

Returns an empty SpannedString.

pub fn concatenate<I>(spans: I) -> Self

where I: IntoIterator<Item = Self>,

Concatenates all styled strings.

Same as spans.into_iter().collect().

pub fn with_spans<S>(source: S, spans: Vec<IndexedSpan<T>>) -> Self

where S: Into<String>,

Creates a new SpannedString manually.

It is not recommended to use this directly. Instead, look for methods like Markdown::parse.

pub fn canonicalize(&mut self)

where T: PartialEq,

Compacts and simplifies this string, resulting in a canonical form.

If two styled strings represent the same styled text, they should have equal canonical forms.

(The PartialEq implementation for StyledStrings requires both the source and spans to be equals, so non-visible changes such as text in the source between spans could cause StyledStrings to evaluate as non-equal.)

pub fn canonical(self) -> Self

where T: PartialEq,

Returns the canonical form of this styled string.

pub fn compact(&mut self)

Compacts the source to only include the spans content.

This does not change the number of spans, but changes the source.

pub fn simplify(&mut self)

where T: PartialEq,

Attemps to reduce the number of spans by merging consecutive similar ones.

pub fn trim_end(&mut self)

Shrink the source to discard any unused suffix.

pub fn trim_start(&mut self)

Shrink the source to discard any unused prefix.

pub fn trim(&mut self)

Shrink the source to discard any unused prefix or suffix.

pub fn single_span<S>(source: S, attr: T) -> Self

where S: Into<String>,

Returns a new SpannedString with a single span.

pub fn append<S>(&mut self, other: S)

where S: Into<Self>,

Appends the given StyledString to self.

pub fn append_raw(&mut self, source: &str, spans: Vec<IndexedSpan<T>>)

Appends content and its corresponding spans to the end.

It is not recommended to use this directly; instead, look at the append method.

pub fn remove_spans<R>(&mut self, range: R)

where R: RangeBounds<usize>,

Remove the given range of spans from the styled string.

You may want to follow this with either compact(), trim_start() or trim_end().

pub fn spans( &self, ) -> impl DoubleEndedIterator<Item = Span<'_, T>> + ExactSizeIterator<Item = Span<'_, T>>

Iterates on the resolved spans.

pub fn spans_attr_mut(&mut self) -> impl Iterator<Item = SpanMut<'_, T>>

Iterates on the resolved spans, with mutable access to the attributes.

pub fn spans_raw(&self) -> &[IndexedSpan<T>]

Returns a reference to the indexed spans.

pub fn spans_raw_attr_mut( &mut self, ) -> impl DoubleEndedIterator<Item = IndexedSpanRefMut<'_, T>> + ExactSizeIterator<Item = IndexedSpanRefMut<'_, T>>

Returns a mutable iterator on the spans of this string.

This can be used to modify the style of each span.

pub fn source(&self) -> &str

Returns a reference to the source string.

This is the non-parsed string.

pub fn into_source(self) -> String

Get the source, consuming this StyledString.

pub fn is_empty(&self) -> bool

Returns true if self is empty.

pub fn width(&self) -> usize

Returns the width taken by this string.

This is the sum of the width of each span.

Trait Implementations

impl<T: Clone> Clone for SpannedString<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for SpannedString<T>

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

Formats the value using the given formatter.

impl<T> Default for SpannedString<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, T> From<&'a SpannedString<T>> for SpannedStr<'a, T>

fn from(other: &'a SpannedString<T>) -> Self

Converts to this type from the input type.

impl<S, T> From<S> for SpannedString<T>

where S: Into<String>, T: Default,

fn from(value: S) -> Self

Converts to this type from the input type.

impl<T> FromIterator<SpannedString<T>> for SpannedString<T>

fn from_iter<I: IntoIterator<Item = SpannedString<T>>>( iter: I, ) -> SpannedString<T>

Creates a value from an iterator.

impl<T: Hash> Hash for SpannedString<T>

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<T: PartialEq> PartialEq for SpannedString<T>

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

type S = IndexedSpan<T>

Type of span returned by SpannedText::spans().

fn source(&self) -> &str

Returns the source text.

fn spans(&self) -> &[IndexedSpan<T>]

Returns the spans for this text.

fn as_ref(&self) -> SpannedTextRef<'_, Self>

Returns a SpannedText by reference.

impl<T: Eq> Eq for SpannedString<T>

impl<T> StructuralPartialEq for SpannedString<T>