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 block model and both serialisations of it, re-exported from pdf-engine: what PdfDocument::extract_blocks hands back, which pages it hands back, and the two ways to write them out (#573).

One definition and not a facade copy of it, for the reason ProcessingLimits is re-exported rather than mirrored: a caller holding a Block from the facade and one from the engine must be holding the same type, or every consumer of both has to convert between two shapes that carry identical fields. 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) -> BlockKind

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<(), Error>

Formats the value using the given formatter.

impl Eq for BlockKind

impl Hash for BlockKind

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

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: &BlockKind) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for BlockKind