Struct doc_chunks::chunk::CheckableChunk

pub struct CheckableChunk { /* private fields */ }

A chunk of documentation that is supposed to be checked.

Implementations

impl CheckableChunk

pub fn from_literalset(set: LiteralSet) -> Self

Specific to rust source code, either as part of doc test comments or file scope.

pub fn from_str(
    content: &str,
    source_mapping: IndexMap<Range, Span>,
    variant: CommentVariant
) -> Self

Load content from string, may contain common mark content.

pub fn from_string(
    content: String,
    source_mapping: IndexMap<Range, Span>,
    variant: CommentVariant
) -> Self

Load content from string, may contain common mark content.

pub fn find_spans(&self, range: Range) -> IndexMap<Range, Span>

Find which part of the range maps to which span. Note that Range can very well be split into multiple fragments where each of them can be mapped to a potentially non-continuous span.

Example:

0..40 -> [
          (0,10) => (1,0)->(3,5),
          (10,12) => (3,6)->(3,7),
          (13,17) => (4,0)->(4,3),
]

pub fn find_covered_spans<'a>(
    &'a self,
    range: Range
) -> impl Iterator<Item = &'a Span>

Extract all spans which at least partially overlap with range, i.e. report all spans that either

• contain range.start
• contain range.end
• are totally enclosed in range

Example:

Below setup results in [s2, s3, s4]

|-- s1 --|-- s2 --|-- s3 --|-- s4 --|
            |----- range -----|

Attention:

For large #[doc="long multiline text"] comments, the covered span might be large (i.e. just one single) which leads to a surprising result of just one span for a relatively small input range.

Below setup results in [s0]

|---...--- s0 ----------------------...---|
            |--- range ---|

pub fn find_covered_lines<'i>(&'i self, range: Range) -> Vec<Range>

Yields a set of ranges covering all spanned lines (the full line).

pub fn extract_line_lengths(&self) -> Result<Vec<usize>>

Extract the overall length of all covered lines as they appear in the origin.

pub fn as_str(&self) -> &str

Obtain the content as str representation.

pub fn display(&self, range: Range) -> ChunkDisplay<'_>

Get the display wrapper type to be used with i.e. format!(..).

pub fn iter(&self) -> Iter<'_, Range, Span>

Iterate over all ranges and the associated span.

pub fn fragment_count(&self) -> usize

Number of fragments.

A fragment is a continuous sub-string which is not split up any further.

pub fn erase_cmark(&self) -> PlainOverlay<'_>

Obtain an accessor object containing mapping and string representation, removing the markdown annotations.

pub fn len_in_chars(&self) -> usize

Obtain the length in characters.

pub fn variant(&self) -> CommentVariant

The variant type of comment.

Trait Implementations

impl Clone for CheckableChunk

fn clone(&self) -> CheckableChunk

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CheckableChunk

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

Formats the value using the given formatter.

impl Hash for CheckableChunk

fn hash<H: Hasher>(&self, hasher: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl PartialEq<CheckableChunk> for CheckableChunk

fn eq(&self, other: &CheckableChunk) -> 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 Eq for CheckableChunk

impl StructuralEq for CheckableChunk

impl StructuralPartialEq for CheckableChunk