Struct text_grid::CellsFormatter

pub struct CellsFormatter<'a, T> { /* private fields */ }

Used to define columns.

• Use column to create column.
• Use column_with to create multi level header.
• Use content to create shared header columns.

Implementations

impl<'a, T> CellsFormatter<'a, T>

pub fn column_with( &mut self, header: impl CellSource, f: impl FnOnce(&mut CellsFormatter<'_, T>) )

Define column group. Used to create multi row header.

• header : Column group header’s cell. If horizontal alignment is not specified, it is set to the center.
• f : A function to define columns in the group.

Examples

use text_grid::*;
struct RowData {
    a: u32,
    b_1: u32,
    b_2: u32,
}
impl CellsSource for RowData {
    fn fmt(f: &mut CellsFormatter<&Self>) {
        f.column("a", |s| s.a);
        f.column_with("b", |f| {
            f.column("1", |s| s.b_1);
            f.column("2", |s| s.b_2);
        });
    }
}

let mut g = Grid::new();
g.push(&RowData {
    a: 300,
    b_1: 10,
    b_2: 20,
});
g.push(&RowData {
    a: 300,
    b_1: 1,
    b_2: 500,
});
assert_eq!(format!("\n{g}"), r#"
  a  |    b     |
-----|----------|
     | 1  |  2  |
-----|----|-----|
 300 | 10 |  20 |
 300 |  1 | 500 |
"#);

Examples found in repository

examples/row_write_group.rs (lines 11-14)

        fn fmt(f: &mut CellsFormatter<&Self>) {
            f.column("a", |s| s.a);
            f.column_with("b", |f| {
                f.column("1", |s| s.b_1);
                f.column("2", |s| s.b_2);
            });
        }

examples/row_write_content.rs (lines 11-15)

        fn fmt(f: &mut CellsFormatter<&Self>) {
            f.column("a", |s| s.a);
            f.column_with("b", |f| {
                f.content(|s| s.b_1);
                f.content(|_| " ");
                f.content(|s| s.b_2);
            });
        }

examples/readme.rs (lines 14-17)

        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 content<U: CellsSource>(&mut self, f: impl FnOnce(&T) -> U)

Define column content. Used to create shared header column.

• f : A function to obtain cells.

Examples

use text_grid::*;
struct RowData {
    a: u32,
    b_1: u32,
    b_2: u32,
}
impl CellsSource for RowData {
    fn fmt(f: &mut CellsFormatter<&Self>) {
        f.column("a", |s| s.a);
        f.column_with("b", |f| {
            f.content(|s| s.b_1);
            f.content(|_| " ");
            f.content(|s| s.b_2);
        });
    }
}

let mut g = Grid::new();
g.push(&RowData {
    a: 300,
    b_1: 10,
    b_2: 20,
});
g.push(&RowData {
    a: 300,
    b_1: 1,
    b_2: 500,
});
assert_eq!(format!("\n{g}"), r#"
  a  |   b    |
-----|--------|
 300 | 10  20 |
 300 |  1 500 |
"#);

Examples found in repository

examples/row_write_content.rs (line 12)

        fn fmt(f: &mut CellsFormatter<&Self>) {
            f.column("a", |s| s.a);
            f.column_with("b", |f| {
                f.content(|s| s.b_1);
                f.content(|_| " ");
                f.content(|s| s.b_2);
            });
        }

pub fn column<U: CellsSource>( &mut self, header: impl CellSource, f: impl FnOnce(&T) -> U )

Define column.

• header : Column header’s cell. If horizontal alignment is not specified, it is set to the center.
• f : A function to obtain cell.

Examples

use text_grid::*;
struct RowData {
    a: u32,
    b: u32,
}
impl CellsSource for RowData {
    fn fmt(f: &mut CellsFormatter<&Self>) {
        f.column("a", |s| s.a);
        f.column("b", |s| s.b);
    }
}

let mut g = Grid::new();
g.push(&RowData { a: 300, b: 1 });
g.push(&RowData { a: 2, b: 200 });
assert_eq!(format!("\n{g}"), r#"
  a  |  b  |
-----|-----|
 300 |   1 |
   2 | 200 |
"#);

Examples found in repository

examples/grid.rs (line 9)

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

examples/grid_schema.rs (line 12)

        fn fmt(&self, f: &mut CellsFormatter<&[u32]>) {
            for i in 0..self.len {
                f.column(i, |s| s[i]);
            }
        }

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/row_write_group.rs (line 10)

        fn fmt(f: &mut CellsFormatter<&Self>) {
            f.column("a", |s| s.a);
            f.column_with("b", |f| {
                f.column("1", |s| s.b_1);
                f.column("2", |s| s.b_2);
            });
        }

examples/row_write_content.rs (line 10)

        fn fmt(f: &mut CellsFormatter<&Self>) {
            f.column("a", |s| s.a);
            f.column_with("b", |f| {
                f.content(|s| s.b_1);
                f.content(|_| " ");
                f.content(|s| s.b_2);
            });
        }

examples/readme.rs (line 11)

        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 map<'x, U: 'x>( &'x mut self, f: impl FnOnce(&T) -> U ) -> CellsFormatter<'x, U>

Creates a CellsFormatter whose source value was converted.

pub fn as_ref(&mut self) -> CellsFormatter<'_, &T>

Creates a CellsFormatter whose source value was converted to reference.

pub fn filter(&mut self, f: impl FnOnce(&T) -> bool) -> CellsFormatter<'_, &T>

Creates a CellsFormatter that outputs the body cell only when the source value satisfies the condition.

pub fn filter_map<'x, U: 'x>( &'x mut self, f: impl FnOnce(&T) -> Option<U> ) -> CellsFormatter<'x, U>

Creates a CellsFormatter that both filters and maps.

pub fn with(&mut self, f: impl Fn(&mut Self))

Apply f to self.

impl<T, E: CellSource> CellsFormatter<'_, Result<T, E>>

pub fn ok_with(&mut self, f: impl FnOnce(&mut CellsFormatter<'_, &T>))

If Ok, output the cells defined by f. If Err, output the cell by the error value using the colspan of the cells output by f.

impl<T, E: CellSource> CellsFormatter<'_, &Result<T, E>>

pub fn ok_with(&mut self, f: impl FnOnce(&mut CellsFormatter<'_, &T>))

If Ok, output the cells defined by f. If Err, output the cell by the error value using the colspan of the cells output by f.