Struct Table

pub struct Table<'a> {
    pub centered: bool,
    /* private fields */
}

Fields

centered: bool

Represents whether or not the table is centered

Implementations

impl Table<'_>

pub fn to_borrowed(&self) -> Table<'_>

pub fn into_owned(self) -> Table<'static>

impl<'a> Table<'a>

pub fn new<I: IntoIterator<Item = (CellPos, Located<Cell<'a>>)>>( cells: I, centered: bool, ) -> Self

pub fn header_rows(&self) -> HeaderRows<'_, 'a>

Returns an iterator over all rows that are considered header rows, which is all rows leading up to a divider row. If there is no divider row, then there are no header rows

pub fn body_rows(&self) -> BodyRows<'_, 'a>

Returns an iterator over all rows that are considered body rows, which is all rows following a divider row. If there is no divider row in the table, then all rows are considered body rows

pub fn has_header_rows(&self) -> bool

Returns true if contains header rows

pub fn has_body_rows(&self) -> bool

Returns true if contains body rows

pub fn has_divider_row(&self) -> bool

Returns true if the table contains a divider row

pub fn get_divider_row_index(&self) -> Option<usize>

Returns the row index representing the divider row of the table (separation between header and body) if it exists

pub fn get_column_alignment(&self, col: usize) -> ColumnAlign

Returns the alignment of the specified column within the table

NOTE: This will always return an alignment, even if the column does not exist, by using the default column alignment

pub fn row_cnt(&self) -> usize

Returns the total rows contained in the table

pub fn col_cnt(&self) -> usize

Returns the total columns contained in the table

pub fn len(&self) -> usize

Returns the total cells (rows * columns) contained in the table

pub fn is_empty(&self) -> bool

Returns true if the total cells (rows * columns) contained in the table is zero

pub fn as_data(&self) -> &HashMap<CellPos, Located<Cell<'a>>>

Returns raw table cell data as a reference to the hashmap

pub fn rows(&self) -> Rows<'_, 'a>

Returns an iterator of refs through all rows in the table

pub fn row(&self, idx: usize) -> Row<'_, 'a>

Returns an iterator of refs through a specific row in the table

pub fn into_row(self, idx: usize) -> IntoRow<'a>

Consumes the table and returns an iterator through a specific row in the table

pub fn columns(&self) -> Columns<'_, 'a>

Returns an iterator of refs through all columns in the table

pub fn column(&self, idx: usize) -> Column<'_, 'a>

Returns an iterator of refs through a specific column in the table

pub fn into_column(self, idx: usize) -> IntoColumn<'a>

Consumes the table and returns an iterator through a specific column in the table

pub fn cells(&self) -> Cells<'_, 'a>

Returns an iterator of refs through all cells in the table, starting from the first row, iterating through all cells from beginning to end, and then moving on to the next row

pub fn into_cells(self) -> IntoCells<'a>

Consumes the table and returns an iterator through all cells in the table, starting from the first row, iterating through all cells from beginning to end, and then moving on to the next row

pub fn get_cell(&self, row: usize, col: usize) -> Option<&Located<Cell<'a>>>

Returns reference to the cell found at the specified row and column

pub fn get_mut_cell( &mut self, row: usize, col: usize, ) -> Option<&mut Located<Cell<'a>>>

Returns mut reference to the cell found at the specified row and column

pub fn get_cell_rowspan(&self, row: usize, col: usize) -> usize

Returns the cell’s rowspan, which is the number of rows (including itself) that the cell spans. 1 means that the cell only spans its starting row whereas >1 indicates it is 1 or more rows below its starting row

Returns 0 for a non-content cell or a cell that doesn’t exist

pub fn get_cell_colspan(&self, row: usize, col: usize) -> usize

Returns the cell’s colspan, which is the number of columns (including itself) that the cell spans. 1 means that the cell only spans its starting column whereas >1 indicates it is 1 or more columns after its starting column

Returns 0 for a non-content cell or a cell that doesn’t exist

Trait Implementations

impl<'a> Clone for Table<'a>

fn clone(&self) -> Table<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Table<'a>

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

Formats the value using the given formatter.

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

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> From<Table<'a>> for BlockElement<'a>

fn from(original: Table<'a>) -> BlockElement<'a>

Converts to this type from the input type.

impl<'a> From<Table<'a>> for Element<'a>

fn from(value: Table<'a>) -> Self

Converts to this type from the input type.

impl<'a> IntoChildren for Table<'a>

type Child = Located<InlineElement<'a>>

The type of child contained within

fn into_children(self) -> Vec<Self::Child>

Returns a vec of children contained within

impl<'a, '__deriveMoreLifetime> IntoIterator for &'__deriveMoreLifetime Table<'a>

type Item = <&'__deriveMoreLifetime HashMap<CellPos, Located<Cell<'a>>> as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'__deriveMoreLifetime HashMap<CellPos, Located<Cell<'a>>> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, '__deriveMoreLifetime> IntoIterator for &'__deriveMoreLifetime mut Table<'a>

type Item = <&'__deriveMoreLifetime mut HashMap<CellPos, Located<Cell<'a>>> as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'__deriveMoreLifetime mut HashMap<CellPos, Located<Cell<'a>>> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for Table<'a>

type Item = <HashMap<CellPos, Located<Cell<'a>>> as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <HashMap<CellPos, Located<Cell<'a>>> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> PartialEq for Table<'a>

fn eq(&self, other: &Table<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Serialize for Table<'a>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> StrictEq for Table<'a>

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

Performs strict_eq on cells and centered status

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

impl<'a> Eq for Table<'a>

impl<'a> StructuralPartialEq for Table<'a>