Struct Table 

pub struct Table {
    pub columns: Vec<TableColumn>,
    pub header_rows: u32,
    pub rows: Vec<Vec<TableCell>>,
    pub caption: Option<Vec<Inline>>,
    pub extra: Extra,
}

A table: { "type": "table", "columns": …, "rows": … } in book.json (the block’s JSON is flat; Block::Table(Table)).

Fields

columns: Vec<TableColumn>

One entry per column: how its text is aligned. Its length is the table’s width.

header_rows: u32

The first header_rows rows are headers (0: none). They repeat on every page in print and are <thead> in the EPUB.

rows: Vec<Vec<TableCell>>

Row by row, only the cells that START in the row: a cell that a rowspan above covers is not listed again.

caption: Option<Vec<Inline>>

Shown above the table.

extra: Extra

Fields written by newer builds, kept on round-trip.

Implementations

impl Table

pub fn new( columns: Vec<TableColumn>, header_rows: u32, rows: Vec<Vec<TableCell>>, ) -> Self

A table, normalized (see Table::normalized): what the importers build. columns may be empty, then the width is the widest row’s.

pub fn with_caption(self, caption: Vec<Inline>) -> Self

The same table with a caption shown above it.

pub fn layout(&self) -> TableLayout<'_>

The grid this table means, by the seven rules below. Total: no stored table panics or loses a cell’s text.

1. The width is columns.len() (or the widest row, see Self::width).
2. A span of 0 is 1; a colspan is cut at the width and at a position a rowspan above covers.
3. Cells are placed row by row, each at the first position at or after the end of the previous one that no rowspan above covers. A cell that does not fit has its text appended, after a line break, to the last cell placed in its row.
4. A rowspan is cut at the last row and at the header boundary (a cell that starts in a header row covers header rows only). A rectangle cannot meet a position already taken: placement goes row by row, so positions below a cell are free until a later row takes them, and that row avoids the covered ones.
5. A position nothing covers and no cell was placed on becomes an empty cell.
6. A row whose every position is covered by rowspans from above cuts those spans to end above it, and is then placed like any row (its listed cells take the freed positions, the rest become empty). The ADR drops the text of such a row’s listed cells; this keeps it, since the rule only exists so that no row is without a cell.
7. header_rows is cut to the number of rows.

pub fn normalized(&self) -> Table

The layout written back as a stored table, in the form importers and Table::new make: one column entry per position, only the cells that start in each row, spans cut, gaps filled with empty cells, header_rows cut. Its layout is this table’s, cell for cell (the source of a cell made up now points at its stored place).

Trait Implementations

impl Clone for Table

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Table

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

Formats the value using the given formatter.

impl Default for Table

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Table

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Table

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Table

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Table