Struct minimad::Compound

pub struct Compound<'s> {
    pub src: &'s str,
    pub bold: bool,
    pub italic: bool,
    pub code: bool,
    pub strikeout: bool,
}

a Compound is a part of a line with a consistent styling. It can be part of word, several words, some inline code, or even the whole line.

Fields

src: &'s str

bold: bool

italic: bool

code: bool

strikeout: bool

Implementations

impl<'s> Compound<'s>

pub fn raw_str(src: &'s str) -> Compound<'s>

make a raw unstyled compound Involves no parsing

pub fn set_str(&mut self, src: &'s str)

change the content but keeps the style arguments

pub fn set_attributes_from(&mut self, other: &Compound<'_>)

change the attributes by taking the values from the other compound, keeping the str

pub fn sub(&self, r_start: usize, r_end: usize) -> Compound<'s>

return a sub part of the compound, with the same styling r_start is relative, that is 0 is the index of the first byte of this compound.

pub fn sub_chars(&self, r_start: usize, r_end: usize) -> Compound<'s>

return a sub part of the compound, with the same styling r_start is relative, that is 0 is the index of the first char of this compound.

The difference with sub is that this method is unicode aware and counts the chars instead of asking for the bytes

pub fn tail(&self, r_start: usize) -> Compound<'s>

return a sub part at end of the compound, with the same styling r_start is relative, that is if you give 0 you get a clone of this compound

pub fn tail_chars(&self, r_start: usize) -> Compound<'s>

return a sub part at end of the compound, with the same styling r_start is relative, that is if you give 0 you get a clone of this compound

The difference with tail is that this method is unicode aware and counts the chars instead of asking for the bytes

pub fn cut_tail(&mut self, tail_size: usize) -> Compound<'s>

pub fn raw_part(src: &'s str, start: usize, end: usize) -> Compound<'s>

pub fn new( src: &'s str, start: usize, end: usize, bold: bool, italic: bool, code: bool, strikeout: bool ) -> Compound<'s>

pub fn bold(self) -> Compound<'s>

pub fn italic(self) -> Compound<'s>

pub fn code(self) -> Compound<'s>

pub fn strikeout(self) -> Compound<'s>

pub fn set_bold(&mut self, bold: bool)

pub fn set_italic(&mut self, italic: bool)

pub fn set_code(&mut self, code: bool)

pub fn set_strikeout(&mut self, strikeout: bool)

pub fn as_str(&self) -> &'s str

pub fn char_length(&self) -> usize

pub fn is_empty(&self) -> bool

Trait Implementations

impl<'s> Clone for Compound<'s>

fn clone(&self) -> Compound<'s>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Compound<'_>

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

Formats the value using the given formatter.

impl Display for Compound<'_>

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

Formats the value using the given formatter.

impl<'s> Hash for Compound<'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> PartialEq for Compound<'s>

fn eq(&self, other: &Compound<'s>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'s> Eq for Compound<'s>

impl<'s> StructuralPartialEq for Compound<'s>