Struct ListItem

pub struct ListItem<'a> {
    pub ty: ListItemType<'a>,
    pub suffix: ListItemSuffix,
    pub pos: usize,
    pub contents: ListItemContents<'a>,
    pub attributes: ListItemAttributes,
}

Represents an item in a list

Fields

ty: ListItemType<'a>

Represents the type of list item

suffix: ListItemSuffix

Represents the suffix of the list

pos: usize

Represents the position of the item in the list starting from 0

contents: ListItemContents<'a>

Represents the contents of the list item

attributes: ListItemAttributes

Represents attributes associated with the list item

Implementations

impl<'a> ListItem<'a>

pub fn new( ty: ListItemType<'a>, suffix: ListItemSuffix, pos: usize, contents: ListItemContents<'a>, attributes: ListItemAttributes, ) -> ListItem<'a>

impl ListItem<'_>

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

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

impl<'a> ListItem<'a>

pub fn is_unordered(&self) -> bool

Indicates whether or not this list item represents an unordered item

pub fn is_ordered(&self) -> bool

Indicates whether or not this list item represents an ordered item

pub fn to_prefix(&self) -> String

Allocates a new string to represent the prefix of this list item

pub fn is_todo(&self) -> bool

Whether or not this list item has TODO information

pub fn compute_todo_progress(&self) -> Option<f32>

Returns percent complete in form of 0.0 == 0% and 1.0 == 100%. This is a calculated percentage based on the sublist items (if there are any) or the item itself.

This will search through all sub list items, check if they have todo properties, and calculate a sum. If none of the sublists or any series of nested sublists contains todo items that are NOT rejected and this item does also not have todo progress, None will be returned.

pub fn is_todo_incomplete(&self) -> bool

Indicates whether or not this element is incomplete, meaning no progress

pub fn is_todo_partially_complete(&self) -> bool

Indicates whether or not this element is partially complete (any range)

pub fn is_todo_partially_complete_1(&self) -> bool

Indicates whether or not this element is partially complete (1-33%)

pub fn is_todo_partially_complete_2(&self) -> bool

Indicates whether or not this element is partially complete (34-66%)

pub fn is_todo_partially_complete_3(&self) -> bool

Indicates whether or not this element is partially complete (67-99%)

pub fn is_todo_complete(&self) -> bool

Indicates whether or not this element is complete

pub fn is_todo_rejected(&self) -> bool

Indicates whether or not this element is rejected

Trait Implementations

impl<'a> Clone for ListItem<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for ListItem<'a>

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

Formats the value using the given formatter.

impl<'a> Default for ListItem<'a>

fn default() -> ListItem<'a>

Returns the “default value” for a type.

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

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

fn from(value: ListItem<'a>) -> Self

Converts to this type from the input type.

impl<'a> From<ListItem<'a>> for InlineBlockElement<'a>

fn from(list_item: ListItem<'a>) -> Self

Converts to this type from the input type.

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

where ListItemContents<'a>: Index<__IdxT>,

type Output = <ListItemContents<'a> as Index<__IdxT>>::Output

The returned type after indexing.

fn index(&self, idx: __IdxT) -> &Self::Output

Performs the indexing (container[index]) operation.

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

where ListItemContents<'a>: IndexMut<__IdxT>,

fn index_mut(&mut self, idx: __IdxT) -> &mut Self::Output

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

impl<'a> IntoChildren for ListItem<'a>

type Child = Located<Element<'a>>

The type of child contained within

fn into_children(self) -> Vec<Self::Child>

Returns a vec of children contained within

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

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

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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

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

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for ListItem<'a>

type Item = <ListItemContents<'a> as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <ListItemContents<'a> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> PartialEq for ListItem<'a>

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> StrictEq for ListItem<'a>

fn strict_eq(&self, other: &Self) -> bool

Performs a strict_eq check against eqivalent variants

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

impl<'a> Eq for ListItem<'a>

impl<'a> StructuralPartialEq for ListItem<'a>