Struct Paragraph

pub struct Paragraph<'a> {
    pub lines: Vec<InlineElementContainer<'a>>,
}

Fields

lines: Vec<InlineElementContainer<'a>>

Represents the lines of content contained within the paragraph

Implementations

impl<'a> Paragraph<'a>

pub fn new(lines: Vec<InlineElementContainer<'a>>) -> Paragraph<'a>

impl<'a> Paragraph<'a>

pub fn is_blank(&self) -> bool

Returns true if the paragraph only contains blank lines (or has no lines at all)

pub fn nonblank_lines( &self, ) -> impl Iterator<Item = &InlineElementContainer<'a>>

Returns an iterator over all lines that are not blank, meaning that they contain non-comment inline elements

impl Paragraph<'_>

pub fn to_borrowed(&self) -> Paragraph<'_>

pub fn into_owned(self) -> Paragraph<'static>

Trait Implementations

impl<'a> Clone for Paragraph<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Paragraph<'a>

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

Formats the value using the given formatter.

impl<'de, 'a> Deserialize<'de> for Paragraph<'a>

fn deserialize<__D>( __deserializer: __D, ) -> Result<Paragraph<'a>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> From<Paragraph<'a>> for BlockElement<'a>

fn from(original: Paragraph<'a>) -> BlockElement<'a>

Converts to this type from the input type.

impl<'a> From<Paragraph<'a>> for Element<'a>

fn from(value: Paragraph<'a>) -> Element<'a>

Converts to this type from the input type.

impl<'a> FromIterator<InlineElementContainer<'a>> for Paragraph<'a>

fn from_iter<I>(iter: I) -> Paragraph<'a>

where I: IntoIterator<Item = InlineElementContainer<'a>>,

Creates a value from an iterator.

impl<'a, __IdxT> Index<__IdxT> for Paragraph<'a>

where Vec<InlineElementContainer<'a>>: Index<__IdxT>,

type Output = <Vec<InlineElementContainer<'a>> as Index<__IdxT>>::Output

The returned type after indexing.

fn index(&self, idx: __IdxT) -> &<Paragraph<'a> as Index<__IdxT>>::Output

Performs the indexing (container[index]) operation.

impl<'a, __IdxT> IndexMut<__IdxT> for Paragraph<'a>

where Vec<InlineElementContainer<'a>>: IndexMut<__IdxT>,

fn index_mut( &mut self, idx: __IdxT, ) -> &mut <Paragraph<'a> as Index<__IdxT>>::Output

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

impl<'a> IntoChildren for Paragraph<'a>

type Child = Located<InlineElement<'a>>

The type of child contained within

fn into_children(self) -> Vec<<Paragraph<'a> as IntoChildren>::Child>

Returns a vec of children contained within

impl<'a, '__deriveMoreLifetime> IntoIterator for &'__deriveMoreLifetime Paragraph<'a>

type Item = <&'__deriveMoreLifetime Vec<InlineElementContainer<'a>> as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'__deriveMoreLifetime Vec<InlineElementContainer<'a>> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'__deriveMoreLifetime Paragraph<'a> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, '__deriveMoreLifetime> IntoIterator for &'__deriveMoreLifetime mut Paragraph<'a>

type Item = <&'__deriveMoreLifetime mut Vec<InlineElementContainer<'a>> as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'__deriveMoreLifetime mut Vec<InlineElementContainer<'a>> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'__deriveMoreLifetime mut Paragraph<'a> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for Paragraph<'a>

type Item = <Vec<InlineElementContainer<'a>> as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <Vec<InlineElementContainer<'a>> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Paragraph<'a> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a> PartialEq for Paragraph<'a>

fn eq(&self, other: &Paragraph<'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> Serialize for Paragraph<'a>

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> StrictEq for Paragraph<'a>

fn strict_eq(&self, other: &Paragraph<'a>) -> bool

Performs strict_eq on content

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

impl<'a> Eq for Paragraph<'a>

impl<'a> StructuralPartialEq for Paragraph<'a>