pub struct Table {
pub rows: Vec<Vec<String>>,
pub location: Option<[u16; 4]>,
pub structure: Option<TableStructure>,
pub cell_blocks: Option<Vec<Vec<Vec<Node>>>>,
pub caption: Option<String>,
pub cells: Option<Vec<TableCell>>,
}Expand description
A simple row-major table. By default rows[0] is the header row; a
TableStructure overlay overrides that and adds column spans.
Fields§
§rows: Vec<Vec<String>>§location: Option<[u16; 4]>Optional layout provenance: the four DocLang <location> values
(x0,y0,x1,y1, each already normalized to the 0–511 resolution) emitted
before the table’s cells. Set only by backends with real geometry (e.g.
the spreadsheet backend, whose cell grid yields a bounding box); left
None by declarative backends, which have no coordinates.
structure: Option<TableStructure>Optional OTSL structure overlay for backends that parse real table
geometry (USPTO CALS): explicit header-row count and horizontal-span
continuations. None → the default (row 0 is the header, no spans).
rows still carries the full text grid (span text replicated) for
Markdown/JSON; DocLang uses this overlay to emit <ched/>/<lcel/>.
cell_blocks: Option<Vec<Vec<Vec<Node>>>>Optional per-cell block content, parallel to rows. A rich cell (an
ODF cell holding a list, several paragraphs, or a nested table) carries
its DocLang blocks here; the DocLang serializer emits them after the
cell token instead of the flat rows text. Markdown/JSON ignore this
and render rows, so their output is unchanged. None (or an empty
Vec for a given cell) → the flat text is used everywhere.
caption: Option<String>Optional caption (docling’s TableItem.captions): the JATS
<table-wrap> label+caption, an HTML <caption>, etc. Markdown renders
it as a text line before the grid; JSON emits a caption text item the
table references; DocLang emits a <caption> as the table’s first child.
None → the table has no caption.
cells: Option<Vec<TableCell>>Optional per-cell bounding boxes, same shape as Self::rows: [l, t, r, b] in page points with a top-left origin (the PDF pipeline’s
native space). Set by the ML pipeline’s TableFormer paths — a spanned
cell repeats its anchor’s box across the covered grid positions — and
First-class cells (#240): the authoritative per-cell records —
text, page geometry, spans and header roles — when the backend
produces them (the PDF TableFormer paths do; declarative backends
leave None). Self::rows stays the dense text grid every
serializer renders (a spanning cell’s text is replicated across its
covered positions there); JSON serializes these cells verbatim when
present, and the DocLang structure overlay is derived from them.
Implementations§
Source§impl Table
impl Table
Sourcepub fn cell_text(&self, row: usize, col: usize) -> Option<&str>
pub fn cell_text(&self, row: usize, col: usize) -> Option<&str>
A cell’s text at a grid position, None outside the grid.
Sourcepub fn set_cell_text(
&mut self,
row: usize,
col: usize,
text: impl Into<String>,
) -> bool
pub fn set_cell_text( &mut self, row: usize, col: usize, text: impl Into<String>, ) -> bool
Replace the text at a grid position; false (and no change) outside
the grid. When a first-class cell covers the position, the whole
cell is updated: its record text and every grid position its span
covers, so the repair shows once in Markdown, not once per covered
column.
Sourcepub fn derive_cells(&self) -> Vec<TableCell>
pub fn derive_cells(&self) -> Vec<TableCell>
Derive first-class cells (#240) from the dense grid plus the
TableStructure overlay — how declarative tables (DOCX/XLSX merged
regions, HTML th/spans, ODF covered cells, USPTO CALS) get real
TableCell records without page geometry. Anchors are the positions
not marked as span continuations; extents scan the continuation grids
right/down (matching the DocLang lcel/ucel reading). Header roles
come from the per-cell col_header/row_header grids when present,
else the header_row band, else docling’s declarative default (row 0
is the header). Without any overlay every position is a 1×1 cell.
Sourcepub fn header_row_count(&self) -> usize
pub fn header_row_count(&self) -> usize
The number of leading grid rows that form the column header —
docling-core’s _count_header_rows (docling-core#723, 2.96) shared by
the Markdown serializer and the chunker’s dataframe view: a row counts
only when a column_header cell starts on it (a header spanning
several rows is replicated into each row it covers, and counting those
would pull the data rows beneath it into the header block). Two
special cases: 1 when no cell carries the flag at all, so tables from
backends that never set it keep row 0 as the header; 0 when flags
exist but none starts on row 0 — then nothing is promotable and every
row stays in the body. Uses the first-class Self::cells when
present (the PDF pipeline’s TableFormer flags), else the cells derived
from the structure overlay.
One deliberate deviation: a row on which a non-header cell with text
also starts does not extend the header block. docling’s HTML backend
flags every <th> as column_header, row headers included, so a pivot
table’s <th rowspan>2025</th> makes upstream fold the first data row
into the header (Year - 2025 | Month - January | …); here that row
stays data. Rows made only of header cells (and empty corners) behave
exactly as upstream. Reported upstream as docling-core#765.
Sourcepub fn cell_at(&self, row: usize, col: usize) -> Option<&TableCell>
pub fn cell_at(&self, row: usize, col: usize) -> Option<&TableCell>
The first-class cell covering a grid position, if any.
Sourcepub fn cell_bbox(&self, row: usize, col: usize) -> Option<[f32; 4]>
pub fn cell_bbox(&self, row: usize, col: usize) -> Option<[f32; 4]>
A cell’s bounding box ([l, t, r, b], page points, top-left origin);
None when no cell with geometry covers the position.
Sourcepub fn set_cell_bbox(&mut self, row: usize, col: usize, bbox: [f32; 4]) -> bool
pub fn set_cell_bbox(&mut self, row: usize, col: usize, bbox: [f32; 4]) -> bool
Set (or replace) the bounding box of the cell covering a grid
position; false outside the text grid. A table without first-class
cells materializes them first (one 1×1 cell per grid position, texts
from the grid), so declarative tables can be annotated too.
Sourcepub fn find_cell_by_bbox(&self, bbox: [f32; 4]) -> Option<(usize, usize)>
pub fn find_cell_by_bbox(&self, bbox: [f32; 4]) -> Option<(usize, usize)>
The anchor position of the cell whose box overlaps bbox best
(largest intersection-over-union), ties resolved in cell order.
None when nothing overlaps or the table carries no geometry. This
is the lookup half of the repair workflow: find the cell an external
OCR box refers to, then Self::set_cell_text it.