Struct text_grid::Cell

pub struct Cell<T> { /* private fields */ }

Implementation of CellSource that can specify styles.

Implementations

impl<T: CellSource> Cell<T>

pub fn new(source: T) -> Self

Create a new Cell with specified CellSource.

pub fn left(self) -> Self

Return the cell with horizontal alignment set to the left.

Examples found in repository

examples/readme.rs (line 13)

        fn fmt(f: &mut CellsFormatter<&Self>) {
            f.column("a", |&s| &s.a);
            f.column("b", |&s| s.b);
            f.column("c", |&s| cell(s.c).left());
            f.column_with("d", |f| {
                f.column("x", |&s| s.d);
                f.column("y", |&s| cells_e!("{:.2e}", s.d));
            });
        }

pub fn right(self) -> Self

Return the cell with horizontal alignment set to the right.

Examples found in repository

examples/cell_macro.rs (line 9)

        fn fmt(f: &mut CellsFormatter<&Self>) {
            f.column("a", |&s| cell!("{:.2}", s.a).right());
            f.column("b", |&s| cell!("{:.3}", s.b).right());
        }

examples/grid_buf.rs (line 5)

fn main() {
    use text_grid::*;
    let mut g = GridBuilder::new();
    g.push(|b| {
        b.push(cell("name").right());
        b.push("type");
        b.push("value");
    });
    g.push_separator();
    g.push(|b| {
        b.push(cell(String::from("X")).right());
        b.push("A");
        b.push(10);
    });
    g.push(|b| {
        b.push(cell("Y").right());
        b.push_with_colspan(cell("BBB").center(), 2);
    });
    print!("{}", g);
}

pub fn center(self) -> Self

Return the cell with horizontal alignment set to the center.

Examples found in repository

examples/grid_buf.rs (line 17)

fn main() {
    use text_grid::*;
    let mut g = GridBuilder::new();
    g.push(|b| {
        b.push(cell("name").right());
        b.push("type");
        b.push("value");
    });
    g.push_separator();
    g.push(|b| {
        b.push(cell(String::from("X")).right());
        b.push("A");
        b.push(10);
    });
    g.push(|b| {
        b.push(cell("Y").right());
        b.push_with_colspan(cell("BBB").center(), 2);
    });
    print!("{}", g);
}

pub fn baseline(self, baseline: &str) -> impl CellsSource

Return the cell with aligned baseline.

use text_grid::*;

struct Source(&'static str);

impl CellsSource for Source {
    fn fmt(f: &mut CellsFormatter<&Self>) {
        f.column("default", |x| &x.0);
        f.column("baseline", |x| cell(&x.0).baseline("-"));
    }
}
let mut g = Grid::new();
g.push(&Source("1-2345"));
g.push(&Source("1234-5"));
g.push(&Source("12345"));

assert_eq!(format!("\n{g}"), r#"
 default |  baseline  |
---------|------------|
 1-2345  |     1-2345 |
 1234-5  |  1234-5    |
 12345   | 12345      |
"#);

pub fn with_base_style(self, style: CellStyle) -> Self

Return the cell with an empty style replaced by the specified style.

Judgment as to whether the style is empty or not is done for each individual element.

impl Cell<String>

pub fn empty() -> Self

Create a new Cell with empty string and empty style.

Trait Implementations

impl<T: CellSource> CellSource for Cell<T>

fn fmt(&self, s: &mut String)

Output the cell text to given buffer.

fn style(&self) -> CellStyle

Return cell’s style.

fn style_for_body(&self) -> CellStyle

impl<T: CellSource> CellsSource for Cell<T>

fn fmt(f: &mut CellsFormatter<'_, &Self>)

Define columns. see CellsFormatter for details.