Struct Cell 

pub struct Cell { /* private fields */ }

A stylable table cell with content.

Implementations

impl Cell

pub fn new<T: ToString>(content: T) -> Self

Create a new Cell

pub fn new_owned(content: String) -> Self

Create a new Cell from an owned String

pub fn content(&self) -> String

Return a copy of the content contained in this cell.

pub fn set_delimiter(self, delimiter: char) -> Self

Set the delimiter used to split text for this cell.
Normal text uses spaces ( ) as delimiters. This is necessary to help super-table understand the concept of words.

pub fn set_alignment(self, alignment: CellAlignment) -> Self

Set the horizontal alignment of content for this cell.

Setting this overwrites alignment settings of the Column for this specific cell.

use super_table::CellAlignment;
use super_table::Cell;

let mut cell = Cell::new("Some content")
    .set_alignment(CellAlignment::Center);

pub fn set_vertical_alignment(self, alignment: VerticalAlignment) -> Self

Set the vertical alignment of content for this cell.

This controls where the content is positioned vertically when the cell’s row has more lines than this cell’s content (e.g., due to another cell in the same row having multi-line content).

Setting this overwrites vertical alignment settings of the Column for this specific cell.

use super_table::VerticalAlignment;
use super_table::Cell;

let mut cell = Cell::new("Some content")
    .set_vertical_alignment(VerticalAlignment::Middle);

pub fn fg(self, color: Color) -> Self

Set the foreground text color for this cell.

Look at Color for a list of all possible Colors.

use super_table::Color;
use super_table::Cell;

let mut cell = Cell::new("Some content")
    .fg(Color::Red);

pub fn bg(self, color: Color) -> Self

Set the background color for this cell.

Look at Color for a list of all possible Colors.

use super_table::Color;
use super_table::Cell;

let mut cell = Cell::new("Some content")
    .bg(Color::Red);

pub fn add_attribute(self, attribute: Attribute) -> Self

Add a styling attribute to the content cell.
Those can be bold, italic, blinking and many more.

Look at Attribute for a list of all possible Colors.

use super_table::Attribute;
use super_table::Cell;

let mut cell = Cell::new("Some content")
    .add_attribute(Attribute::Bold);

pub fn add_attributes(self, attribute: Vec<Attribute>) -> Self

Same as add_attribute, but you can pass a vector of Attributes

pub fn set_colspan(self, cols: u16) -> Self

Set the number of columns this cell spans.

By default, a cell spans 1 column. Setting a colspan greater than 1 makes the cell occupy multiple columns. The cell’s content will be rendered across all spanned columns, and borders between the spanned columns will be omitted.

Examples

use super_table::{Cell, Table};

let mut table = Table::new();
table
    .set_header(vec![
        Cell::new("Header1").set_colspan(2),
        Cell::new("Header3"),
    ])
    .add_row(vec![
        Cell::new("Spans 2 columns").set_colspan(2),
        Cell::new("Normal cell"),
    ]);

Notes

• When using colspan, you should add fewer cells to the row than the number of columns. The spanned cell counts as multiple columns.
• Colspan works with all table features including styling, alignment, and dynamic width arrangement.
• Hidden columns are automatically excluded from colspan calculations.

pub fn set_rowspan(self, rows: u16) -> Self

Set the number of rows this cell spans.

By default, a cell spans 1 row. Setting a rowspan greater than 1 makes the cell occupy multiple rows. The cell’s content will appear only in the first row of the span, and subsequent rows will have empty space where the rowspan cell is located.

Examples

use super_table::{Cell, Table};

let mut table = Table::new();
table
    .set_header(vec!["Header1", "Header2", "Header3"])
    .add_row(vec![
        Cell::new("Spans 2 rows").set_rowspan(2),
        Cell::new("Cell 2"),
        Cell::new("Cell 3"),
    ])
    .add_row(vec![
        // First position is occupied by rowspan above, so only add 2 cells
        Cell::new("Cell 2 (row 2)"),
        Cell::new("Cell 3 (row 2)"),
    ]);

Notes

• When using rowspan, subsequent rows should have fewer cells than the number of columns, as the rowspan cell occupies space in those rows.
• Rowspan content appears only in the starting row of the span.
• Rowspan works with all table features including styling, alignment, and multi-line content.
• You can combine rowspan with colspan to create cells that span both multiple rows and columns.

pub fn colspan(&self) -> u16

Get the number of columns this cell spans.

Returns 1 if no colspan is set (default behavior).

use super_table::Cell;

let cell = Cell::new("Content");
assert_eq!(cell.colspan(), 1);

let cell = Cell::new("Content").set_colspan(3);
assert_eq!(cell.colspan(), 3);

pub fn rowspan(&self) -> u16

Get the number of rows this cell spans.

Returns 1 if no rowspan is set (default behavior).

use super_table::Cell;

let cell = Cell::new("Content");
assert_eq!(cell.rowspan(), 1);

let cell = Cell::new("Content").set_rowspan(2);
assert_eq!(cell.rowspan(), 2);

pub fn span_columns(self, cols: u16) -> Self

Alias for set_colspan.

use super_table::Cell;

let cell = Cell::new("Spans 2 columns")
    .span_columns(2);

pub fn span_rows(self, rows: u16) -> Self

Alias for set_rowspan.

use super_table::Cell;

let cell = Cell::new("Spans 2 rows")
    .span_rows(2);

Trait Implementations

impl Clone for Cell

fn clone(&self) -> Cell

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Cell

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

Formats the value using the given formatter.

impl<T: ToString> From<T> for Cell

Convert anything with ToString to a new Cell.

let cell: Cell = "content".into();
let cell: Cell = 5u32.into();

fn from(content: T) -> Self

Converts to this type from the input type.

impl Hash for Cell

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 Cell

fn eq(&self, other: &Cell) -> 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 Eq for Cell

impl StructuralPartialEq for Cell