Struct TableFormatter 

pub struct TableFormatter<'src, T: DefaultTableStyle<N>, const N: usize> { /* private fields */ }

The main structure used for table printing. This stores information about columns and has methods for writing table results to a Write object.

Implementations

impl<T: DefaultTableStyle<N>, const N: usize> TableFormatter<'static, T, N>

pub fn from_style() -> Self

Creates a new TableFormatter from a type that implements DefaultTableStyle. This will automatically generate the columns of this formatter suited to the type.

Examples found in repository

examples/writer.rs (line 16)

pub fn main() {
    let table = TableFormatter::from_style();

    let data = [
        [1, 0, 0, 0],
        [0, 1, 0, 0],
        [0, 0, 1, 0],
        [0, 0, 0, 1]
    ];

    let mut out = stdout().lock();

    if let Err(err) = table.write(&mut out, data) {
        panic!("Failed to print table due to {}.", err.kind());
    }

    let _ = out.flush();
}

examples/array.rs (line 8)

pub fn main() {
    // Create a table using the default formatter for [&str; 3], the
    // type we are supplying into it.
    let table = TableFormatter::from_style();

    // Put the data we want to print into a collection.
    let data = [
        ["These", "arrays", "need"],
        ["to", "be", "the"],
        ["same", "size", ":)"]
    ];

    // Call debug_print to write the output to console— use 
    // "let _ = ..." to ignore the output.
    let _ = table.debug_print(data);
}

examples/tuple.rs (line 9)

pub fn main() {
    // Create a table using the default formatter for (&str, i32, bool), the
    // type we are supplying into it.
    let table = TableFormatter::from_style();

    // Put the data we want to print into a collection.
    let data = [
        ("Hello, world!", 2, true),
        ("hello", 0, true),
        ("meow", 123, false),
    ];

    // Call debug_print to write the output to console— use 
    // "let _ = ..." to ignore the output.
    let _ = table.debug_print(data);
}

examples/derive.rs (line 24)

fn dictionary_struct() {
    // Create a table using the default formatter for MyDictionaryStruct.
    // This default formatter was created by deriving DefaultTableStyle above.
    let table = TableFormatter::from_style();

    // Don't format this into a million lines please it's fine like this
    #[rustfmt::skip]
    let data = [
        MyDictionaryStruct { name: "Susan", age: 42, adult: true },
        MyDictionaryStruct { name: "Ashli", age: 19, adult: true },
        MyDictionaryStruct { name: "Groot", age: 5, adult: false },
        MyDictionaryStruct { name: "Henry", age: 53, adult: true },
        MyDictionaryStruct { name: "Whatever", age: 17, adult: false },
    ];

    // Print our results. We are able to use MyDictionaryStruct here
    // because we derived DebugTableRow earlier.
    let _ = table.debug_print(data);
}

fn tuple_struct() {
    // Create a table using the default formatter for MyTupleStruct. This
    // default formatter was created by deriving DefaultTableStyle above.
    let table = TableFormatter::from_style();

    let data = [
        MyTupleStruct(7, -10, -3),
        MyTupleStruct(6, -7, -1),
        MyTupleStruct(5, -4, 1),
        MyTupleStruct(4, -1, 3),
        MyTupleStruct(3, 2, 5),
        MyTupleStruct(2, 5, 7),
        MyTupleStruct(1, 8, 9),
        MyTupleStruct(0, 11, 11),
        MyTupleStruct(-1, 14, 13),
        MyTupleStruct(-2, 17, 15),
    ];

    // Print our results. We are able to use MyTupleStruct here
    // because we derived DebugTableRow earlier.
    let _ = table.debug_print(data);
}

impl<'src, T: DefaultTableStyle<N>, const N: usize> TableFormatter<'src, T, N>

pub const fn new(columns: [Column<'src>; N]) -> Self

Create a new TableFormatter from an array of columns.

Examples found in repository

examples/custom.rs (lines 10-31)

pub fn main() {
    // Import these two fields for brevity in the following section.
    use ColumnAlign::*;
    use ColumnSize::*;

    let formatter = TableFormatter::new([
        // Column 1 will use the default settings. These are used by tuples.
        Column::default(),
        // This is the same as column 1, but written more explicitly.
        // It has no title, will fit the data in its column, is left-aligned,
        // and has a padding of 1 space
        Column::new(None, Contain, Left, 1),
        // Similar to column 2, but has a title.
        // This column will grow to accomodate its data, but only up to 7
        // characters— data will be split with newlines if needed.
        //
        // Because this column has a title, all columns without titles in
        // this graph will get a blank title when printed.
        Column::new(Some(("Fruit", Left)), ContainMax(5), Left, 1),
        // This column has a fixed width of 32, and has 5 spaces
        // of padding around the data, which is centered. Note that the
        // actual width of this column will be 42 (32 + 5 + 5) due
        // to the padding.
        Column::new(None, Fixed(12), Centered, 5),
        // You should be able to tell how this one will look by this point.
        Column::new(Some(("Data", Centered)), Fixed(8), Right, 1),
    ]);

    // The above formatter has 5 columns specified, so any data we put in
    // must turn into a [String; 5] with DebugTableRow— this is true
    // for length-5 tuples.
    let data = [
        (1, 'H', "Apple", true, 2.3),
        (2, 'E', "Pineapple", false, 5.5),
        (3, 'L', "Kiwi", false, 11.5),
        (4, 'L', "Banana", true, 0.5),
        (5, 'O', "Strawberry", false, 0.25)
    ];

    // Print data just as normal.
    let _ = formatter.debug_print(data);
}

impl<'src, T: DefaultTableStyle<N> + DebugTableRow<N>, const N: usize> TableFormatter<'src, T, N>

pub fn debug_write( &self, out: &mut impl Write, rows: impl IntoIterator<Item = T>, ) -> Result<()>

Takes a Write and data that implements [DebugTable]— prints a table of the input data to the Write object. The resulting table will appear messed up if the cursor is not at the beginning of a new line.

For user-visible output, use write.

pub fn debug_print(&self, rows: impl IntoIterator<Item = T>) -> Result<()>

Same as debug_write but always writes to stdout.

Examples found in repository

examples/array.rs (line 19)

pub fn main() {
    // Create a table using the default formatter for [&str; 3], the
    // type we are supplying into it.
    let table = TableFormatter::from_style();

    // Put the data we want to print into a collection.
    let data = [
        ["These", "arrays", "need"],
        ["to", "be", "the"],
        ["same", "size", ":)"]
    ];

    // Call debug_print to write the output to console— use 
    // "let _ = ..." to ignore the output.
    let _ = table.debug_print(data);
}

examples/tuple.rs (line 20)

pub fn main() {
    // Create a table using the default formatter for (&str, i32, bool), the
    // type we are supplying into it.
    let table = TableFormatter::from_style();

    // Put the data we want to print into a collection.
    let data = [
        ("Hello, world!", 2, true),
        ("hello", 0, true),
        ("meow", 123, false),
    ];

    // Call debug_print to write the output to console— use 
    // "let _ = ..." to ignore the output.
    let _ = table.debug_print(data);
}

examples/derive.rs (line 38)

fn dictionary_struct() {
    // Create a table using the default formatter for MyDictionaryStruct.
    // This default formatter was created by deriving DefaultTableStyle above.
    let table = TableFormatter::from_style();

    // Don't format this into a million lines please it's fine like this
    #[rustfmt::skip]
    let data = [
        MyDictionaryStruct { name: "Susan", age: 42, adult: true },
        MyDictionaryStruct { name: "Ashli", age: 19, adult: true },
        MyDictionaryStruct { name: "Groot", age: 5, adult: false },
        MyDictionaryStruct { name: "Henry", age: 53, adult: true },
        MyDictionaryStruct { name: "Whatever", age: 17, adult: false },
    ];

    // Print our results. We are able to use MyDictionaryStruct here
    // because we derived DebugTableRow earlier.
    let _ = table.debug_print(data);
}

fn tuple_struct() {
    // Create a table using the default formatter for MyTupleStruct. This
    // default formatter was created by deriving DefaultTableStyle above.
    let table = TableFormatter::from_style();

    let data = [
        MyTupleStruct(7, -10, -3),
        MyTupleStruct(6, -7, -1),
        MyTupleStruct(5, -4, 1),
        MyTupleStruct(4, -1, 3),
        MyTupleStruct(3, 2, 5),
        MyTupleStruct(2, 5, 7),
        MyTupleStruct(1, 8, 9),
        MyTupleStruct(0, 11, 11),
        MyTupleStruct(-1, 14, 13),
        MyTupleStruct(-2, 17, 15),
    ];

    // Print our results. We are able to use MyTupleStruct here
    // because we derived DebugTableRow earlier.
    let _ = table.debug_print(data);
}

examples/custom.rs (line 45)

pub fn main() {
    // Import these two fields for brevity in the following section.
    use ColumnAlign::*;
    use ColumnSize::*;

    let formatter = TableFormatter::new([
        // Column 1 will use the default settings. These are used by tuples.
        Column::default(),
        // This is the same as column 1, but written more explicitly.
        // It has no title, will fit the data in its column, is left-aligned,
        // and has a padding of 1 space
        Column::new(None, Contain, Left, 1),
        // Similar to column 2, but has a title.
        // This column will grow to accomodate its data, but only up to 7
        // characters— data will be split with newlines if needed.
        //
        // Because this column has a title, all columns without titles in
        // this graph will get a blank title when printed.
        Column::new(Some(("Fruit", Left)), ContainMax(5), Left, 1),
        // This column has a fixed width of 32, and has 5 spaces
        // of padding around the data, which is centered. Note that the
        // actual width of this column will be 42 (32 + 5 + 5) due
        // to the padding.
        Column::new(None, Fixed(12), Centered, 5),
        // You should be able to tell how this one will look by this point.
        Column::new(Some(("Data", Centered)), Fixed(8), Right, 1),
    ]);

    // The above formatter has 5 columns specified, so any data we put in
    // must turn into a [String; 5] with DebugTableRow— this is true
    // for length-5 tuples.
    let data = [
        (1, 'H', "Apple", true, 2.3),
        (2, 'E', "Pineapple", false, 5.5),
        (3, 'L', "Kiwi", false, 11.5),
        (4, 'L', "Banana", true, 0.5),
        (5, 'O', "Strawberry", false, 0.25)
    ];

    // Print data just as normal.
    let _ = formatter.debug_print(data);
}

impl<'src, T: DefaultTableStyle<N> + DisplayTableRow<N>, const N: usize> TableFormatter<'src, T, N>

pub fn write( &self, out: &mut impl Write, rows: impl IntoIterator<Item = T>, ) -> Result<()>

Takes a Write (such as Stdout) and data that implements [DisplayTable]— prints a table of the input data to the Write object. The resulting table will appear messed up if the cursor is not at the beginning of a new line.

For debugging, use debug_write.

Examples found in repository

examples/writer.rs (line 27)

pub fn main() {
    let table = TableFormatter::from_style();

    let data = [
        [1, 0, 0, 0],
        [0, 1, 0, 0],
        [0, 0, 1, 0],
        [0, 0, 0, 1]
    ];

    let mut out = stdout().lock();

    if let Err(err) = table.write(&mut out, data) {
        panic!("Failed to print table due to {}.", err.kind());
    }

    let _ = out.flush();
}

pub fn print(&self, rows: impl IntoIterator<Item = T>) -> Result<()>

Same as write but always writes to stdout.

Trait Implementations

impl<'src, T: DefaultTableStyle<N>, const N: usize> Default for TableFormatter<'src, T, N>

fn default() -> Self

Returns the “default value” for a type.