Struct term_grid::Grid

pub struct Grid<T: AsRef<str>> { /* private fields */ }

Everything needed to format the cells with the grid options.

Implementations

impl<T: AsRef<str>> Grid<T>

pub fn new(cells: Vec<T>, options: GridOptions) -> Self

Creates a new grid view with the given cells and options

Examples found in repository

examples/basic.rs (lines 19-26)

fn main() {
    let cells: Vec<_> = (0..48).map(|i| 2_isize.pow(i).to_string()).collect();

    let grid = Grid::new(
        cells,
        GridOptions {
            direction: Direction::TopToBottom,
            filling: Filling::Text(" | ".into()),
            width: 80,
        },
    );

    println!("{}", grid);
}

examples/big.rs (lines 15-22)

fn main() {
    let mut n: u64 = 1234;
    for _ in 0..50 {
        let mut cells = Vec::new();
        for _ in 0..10000 {
            cells.push(n.to_string());
            n = n.overflowing_pow(2).0 % 100000000;
        }

        let grid = Grid::new(
            cells,
            GridOptions {
                direction: Direction::TopToBottom,
                filling: Filling::Text(" | ".into()),
                width: 80,
            },
        );

        println!("{grid}");
    }
}

pub fn width(&self) -> usize

The number of terminal columns this display takes up, based on the separator width and the number and width of the columns.

pub fn row_count(&self) -> usize

The number of rows this display takes up.

pub fn column_widths(&self) -> &[usize]

The width of each column

pub fn is_complete(&self) -> bool

Returns whether this display takes up as many columns as were allotted to it.

It’s possible to construct tables that don’t actually use up all the columns that they could, such as when there are more columns than cells! In this case, a column would have a width of zero. This just checks for that.

Trait Implementations

impl<T: Debug + AsRef<str>> Debug for Grid<T>

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

Formats the value using the given formatter.

impl<T: AsRef<str>> Display for Grid<T>

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

Formats the value using the given formatter.