Struct CompactTable

pub struct CompactTable<I, D> { /* private fields */ }

A table which consumes an IntoRecords iterator. It assumes that the content has only single line.

In contrast to Table CompactTable does no allocations but it consumes an iterator. It’s useful when you don’t want to re/allocate a buffer for your data.

Example

It works smoothly with arrays.

use tabled::{settings::Style, tables::CompactTable};

let data = [
    ["FreeBSD", "1993", "William and Lynne Jolitz", "?"],
    ["OpenBSD", "1995", "Theo de Raadt", ""],
    ["HardenedBSD", "2014", "Oliver Pinter and Shawn Webb", ""],
];

let table = CompactTable::from(data)
    .with(Style::psql())
    .to_string();

assert_eq!(
    table,
    concat!(
        " FreeBSD     | 1993 | William and Lynne Jolitz     | ? \n",
        " OpenBSD     | 1995 | Theo de Raadt                |   \n",
        " HardenedBSD | 2014 | Oliver Pinter and Shawn Webb |   ",
    )
);

But it’s default creation requires to be given an estimated cell width, and the amount of columns.

use tabled::{settings::Style, tables::CompactTable};

let data = [
    ["FreeBSD", "1993", "William and Lynne Jolitz", "?"],
    ["OpenBSD", "1995", "Theo de Raadt", ""],
    ["HardenedBSD", "2014", "Oliver Pinter and Shawn Webb", ""],
];

// See what will happen if the given width is too narrow

let table = CompactTable::new(&data)
    .columns(4)
    .width(5)
    .with(Style::ascii())
    .to_string();

assert_eq!(
    table,
    "+-----+-----+-----+-----+\n\
     | FreeBSD | 1993 | William and Lynne Jolitz | ?   |\n\
     |-----+-----+-----+-----|\n\
     | OpenBSD | 1995 | Theo de Raadt |     |\n\
     |-----+-----+-----+-----|\n\
     | HardenedBSD | 2014 | Oliver Pinter and Shawn Webb |     |\n\
     +-----+-----+-----+-----+"
);

Implementations

impl<I> CompactTable<I, ConstDimension<0, 0>>

pub const fn new(iter: I) -> Self

where I: IntoRecords,

Creates a new CompactTable structure with a width dimension for all columns.

impl<I, const ROWS: usize, const COLS: usize> CompactTable<I, ConstDimension<COLS, ROWS>>

pub fn height<S: Into<ConstSize<COUNT_ROWS>>, const COUNT_ROWS: usize>( self, size: S, ) -> CompactTable<I, ConstDimension<COLS, COUNT_ROWS>>

Set a height for each row.

pub fn width<S: Into<ConstSize<COUNT_COLUMNS>>, const COUNT_COLUMNS: usize>( self, size: S, ) -> CompactTable<I, ConstDimension<COUNT_COLUMNS, ROWS>>

Set a width for each column.

impl<I, D> CompactTable<I, D>

pub fn with_dimension(iter: I, dimension: D) -> Self

where I: IntoRecords,

Creates a new CompactTable structure with a known dimension.

Notice that the function wont call Estimate.

pub fn with<O>(self, option: O) -> Self

where for<'a> O: TableOption<IterRecords<&'a I>, CompactConfig, D>,

With is a generic function which applies options to the CompactTable.

Examples found in repository

examples/compact_table.rs (line 13)

fn main() {
    let data = [
        ["Debian", "1.1.1.1", "true"],
        ["Arch", "127.1.1.1", "true"],
        ["Manjaro", "Arch", "true"],
        ["Manjaro", "A\nr\nc\nh", "true"],
    ];

    let table = CompactTable::from(data).with(Style::ascii());

    #[cfg(feature = "std")]
    println!("{}", table.to_string());
}

examples/no_std.rs (line 10)

fn main() {
    let data = [
        ["Debian", "1.1.1.1", "true"],
        ["Arch", "127.1.1.1", "true"],
        ["Manjaro", "Arch", "true"],
    ];

    let table = CompactTable::from(data).with(Style::modern());
    let mut buf = [0; 1024 * 10];
    let mut w = Writer::new(&mut buf);

    table.fmt(&mut w).unwrap();

    assert_table!(w.as_str(),
        "┌─────────┬───────────┬──────┐"
        "│ Debian  │ 1.1.1.1   │ true │"
        "│─────────┼───────────┼──────│"
        "│ Arch    │ 127.1.1.1 │ true │"
        "│─────────┼───────────┼──────│"
        "│ Manjaro │ Arch      │ true │"
        "└─────────┴───────────┴──────┘"
    );
}

pub const fn rows(self, count_rows: usize) -> Self

Limit a number of rows.

pub const fn columns(self, count: usize) -> Self

Limit a number of columns.

pub fn get_config(&self) -> &CompactConfig

Returns a table config.

pub fn get_config_mut(&mut self) -> &mut CompactConfig

Returns a table config.

pub fn fmt<W>(self, writer: W) -> Result

where I: IntoRecords, I::Cell: AsRef<str>, D: Dimension, W: Write,

Format table into fmt::Writeer.

Examples found in repository

examples/no_std.rs (line 14)

fn main() {
    let data = [
        ["Debian", "1.1.1.1", "true"],
        ["Arch", "127.1.1.1", "true"],
        ["Manjaro", "Arch", "true"],
    ];

    let table = CompactTable::from(data).with(Style::modern());
    let mut buf = [0; 1024 * 10];
    let mut w = Writer::new(&mut buf);

    table.fmt(&mut w).unwrap();

    assert_table!(w.as_str(),
        "┌─────────┬───────────┬──────┐"
        "│ Debian  │ 1.1.1.1   │ true │"
        "│─────────┼───────────┼──────│"
        "│ Arch    │ 127.1.1.1 │ true │"
        "│─────────┼───────────┼──────│"
        "│ Manjaro │ Arch      │ true │"
        "└─────────┴───────────┴──────┘"
    );
}

pub fn build<W>(self, writer: W) -> Result<()>

where I: IntoRecords, I::Cell: AsRef<str>, D: Dimension, W: Write,

Available on crate feature std only.

Format table into a writer.

pub fn to_string(self) -> String

where I: IntoRecords, I::Cell: AsRef<str>, D: Dimension,

Available on crate feature std only.

Build a string.

We can’t implement std::string::ToString cause it does takes &self reference.

Examples found in repository

examples/compact_table.rs (line 16)

fn main() {
    let data = [
        ["Debian", "1.1.1.1", "true"],
        ["Arch", "127.1.1.1", "true"],
        ["Manjaro", "Arch", "true"],
        ["Manjaro", "A\nr\nc\nh", "true"],
    ];

    let table = CompactTable::from(data).with(Style::ascii());

    #[cfg(feature = "std")]
    println!("{}", table.to_string());
}

Trait Implementations

impl<I: Clone, D: Clone> Clone for CompactTable<I, D>

fn clone(&self) -> CompactTable<I, D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: Debug, D: Debug> Debug for CompactTable<I, D>

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

Formats the value using the given formatter.

impl<T, const ROWS: usize, const COLS: usize> From<[[T; COLS]; ROWS]> for CompactTable<[[T; COLS]; ROWS], ConstDimension<COLS, ROWS>>

where T: AsRef<str>,

fn from(mat: [[T; COLS]; ROWS]) -> Self

Converts to this type from the input type.