Enum BlockKind 

#[non_exhaustive]
pub enum BlockKind {
    Paragraph,
    Heading {
        level: u8,
    },
    ListItem {
        level: u8,
        ordinal: Option<u32>,
    },
    TableCell {
        row: u16,
        column: u16,
        row_span: u16,
        column_span: u16,
        header: bool,
    },
    Header,
    Footer,
    Caption,
    Figure,
}

The kind of a block. Paragraphs (#567), headings (#568) and list items (#569); tables and running heads arrive with theirs (#570, #571).

#[non_exhaustive] because those variants land in a published crate: a caller that matches on this must keep a fallback arm, and adding a kind must not be a breaking change.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Paragraph

Running text: one or more lines the page sets as one paragraph.

Heading

A heading, at a level from 1 to 3 (#568).

The level is the block’s rank among the type the DOCUMENT sets above its own body, never a point size: see crate::headings. Levels below the third fold into it, so level is always 1, 2 or 3 and a consumer mapping it to #..###### never runs off the end.

Fields

level: u8

1, 2 or 3.

ListItem

One item of a list (#569).

ONE BLOCK PER ITEM, not one per list. The item is what a caller chunks, cites and embeds – the same unit every other kind here is – and a container kind would need a second shape of Block, with its own text and its own box, for a grouping that consecutive items already say. A list is therefore a run of adjacent blocks of this kind, and the markdown serializer reads it as one.

The marker itself is NOT in Block::text: a bullet and a number are what the page used to say “item”, and a consumer that wanted them back would have to strip them again before indexing the words. It is still in Block::spans, which carry what the page drew rather than what it said. The one exception is an outline’s number – II.4.1, 10.2 – which stays at the head of the text, because it is the clause’s name as much as its marker: a cross-reference cites it, and no one ordinal can say it (#599).

Fields

level: u8

Nesting depth, 0 for the outermost list. From the indent steps the column itself uses, never a measurement in points, and never more than four: deeper steps fold into the fourth, the way heading clusters below the third fold into level 3.

ordinal: Option<u32>

The number the document wrote – 3. is 3, c) is 3, iv. is 4 – or None where the item was marked with a bullet, or numbered by its place in an outline (II.4.1), which no one number says and which the item’s text therefore keeps.

The document’s own number and not a count of this list’s items, so a list that opens at 5, or one the extraction lost an item out of, still says what the page says.

TableCell

One cell of a table (#570).

ONE BLOCK PER CELL, for the reason a list is one block per item: the cell is what a caller chunks, cites and embeds, and a container kind would need a second shape of Block – its own text, its own box – for a grouping that row, column and a run of adjacent blocks already say. A table is therefore a run of these in ROW-MAJOR order, opening at row: 0, column: 0, and crate::markdown reads such a run back as one table.

The grid is the whole table’s, not the row’s: column is a column of the table, so the third cell of a row whose second cell is missing is at column 2 and not at column 1.

Fields

row: u16

0-based row inside the table.

column: u16

0-based column inside the table.

row_span: u16

How many rows the cell covers, 1 unless the document ruled two rows together by breaking the rule between them over this column.

column_span: u16

How many columns the cell covers, 1 unless its words cross a column boundary the rest of the table keeps.

header: bool

Whether the cell is in the table’s header row.

Header

A running header: the line a document repeats at the TOP of its pages (#571).

Not in the reading order. crate::reading_order keeps these blocks after the body rather than dropping them, because what a page repeats is still something a caller may want to read – the chapter it is in, the revision of the form – and it is the body it must not interrupt.

Footer

A running footer, including a page number (#571).

The same block as BlockKind::Header at the other end of the page: see there for why it is kept rather than dropped.

Caption

A caption: the line or lines that say what a picture or a table beside them shows (#636). Read by the learned pass from where the page draws its images; the heuristics never produce one.

Figure

A figure: a placed image or a drawn vector cluster on the page (#658).

Listed late, after the learned pass and the text joins, from the figure boxes the text pass recorded: placed images first, then the path clusters [crate::text::TextExtractionDevice::take_graphics] keeps. A page with no text block still carries its placed images – a scan reads as its figure markers – but no drawn cluster, and figures merge into their page’s reading order by vertical position.

Block::text is empty: a figure says nothing; the Markdown serializer writes it as an image reference from its page and its number among that page’s figures.

Trait Implementations

impl Clone for BlockKind

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for BlockKind

impl Debug for BlockKind

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

Formats the value using the given formatter.

impl Eq for BlockKind

impl Hash for BlockKind

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 PartialEq for BlockKind

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for BlockKind