Struct tabled::tables::Table

pub struct Table { /* private fields */ }

Available on crate feature std only.

The structure provides an interface for building a table for types that implements Tabled.

To build a string representation of a table you must use a std::fmt::Display. Or simply call .to_string() method.

The default table Style is Style::ascii, with a 1 left and right Padding.

Example

Basic usage

use tabled::Table;

let table = Table::new(&["Year", "2021"]);

With settings

use tabled::{Table, settings::{Style, Alignment}};

let data = vec!["Hello", "2021"];
let mut table = Table::new(&data);
table.with(Style::psql()).with(Alignment::left());

println!("{}", table);

Implementations

impl Table

pub fn new<I, T>(iter: I) -> Self

where I: IntoIterator<Item = T>, T: Tabled,

New creates a Table instance.

If you use a reference iterator you’d better use FromIterator instead. As it has a different lifetime constraints and make less copies therefore.

pub fn builder<I, T>(iter: I) -> Builder

where T: Tabled, I: IntoIterator<Item = T>,

Creates a builder from a data set given.

Example

use tabled::{
    Table, Tabled,
    settings::{object::Segment, Modify, Alignment}
};

#[derive(Tabled)]
struct User {
    name: &'static str,
    #[tabled(inline("device::"))]
    device: Device,
}

#[derive(Tabled)]
enum Device {
    PC,
    Mobile
}

let data = vec![
    User { name: "Vlad", device: Device::Mobile },
    User { name: "Dimitry", device: Device::PC },
    User { name: "John", device: Device::PC },
];

let mut table = Table::builder(data)
    .index()
    .column(0)
    .transpose()
    .build()
    .with(Modify::new(Segment::new(1.., 1..)).with(Alignment::center()))
    .to_string();

assert_eq!(
    table,
    "+----------------+------+---------+------+\n\
     | name           | Vlad | Dimitry | John |\n\
     +----------------+------+---------+------+\n\
     | device::PC     |      |    +    |  +   |\n\
     +----------------+------+---------+------+\n\
     | device::Mobile |  +   |         |      |\n\
     +----------------+------+---------+------+"
)

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

where for<'a> O: TableOption<VecRecords<CellInfo<String>>, ColoredConfig, CompleteDimensionVecRecords<'a>>,

It’s a generic function which applies options to the Table.

It applies settings immediately.

pub fn modify<T, O>(&mut self, target: T, option: O) -> &mut Self

where T: Object<VecRecords<CellInfo<String>>>, O: CellOption<VecRecords<CellInfo<String>>, ColoredConfig> + Clone,

It’s a generic function which applies options to a particalar cells on the Table. Target cells using Objects such as Cell, Rows, Location and more.

It applies settings immediately.

pub fn shape(&self) -> (usize, usize)

Returns a table shape (count rows, count columns).

pub fn count_rows(&self) -> usize

Returns an amount of rows in the table.

pub fn count_columns(&self) -> usize

Returns an amount of columns in the table.

pub fn is_empty(&self) -> bool

Returns a table shape (count rows, count columns).

pub fn total_height(&self) -> usize

Returns total widths of a table, including margin and horizontal lines.

pub fn total_width(&self) -> usize

Returns total widths of a table, including margin and vertical lines.

pub fn get_config(&self) -> &ColoredConfig

Returns a table config.

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

Returns a table config.

pub fn get_records(&self) -> &VecRecords<CellInfo<String>>

Returns a used records.

pub fn get_records_mut(&mut self) -> &mut VecRecords<CellInfo<String>>

Returns a used records.

Trait Implementations

impl Clone for Table

fn clone(&self) -> Table

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Table

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

Formats the value using the given formatter.

impl Default for Table

fn default() -> Self

Returns the “default value” for a type.

impl Display for Table

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

Formats the value using the given formatter.

impl From<Builder> for Table

fn from(builder: Builder) -> Self

Converts to this type from the input type.

impl From<Table> for Builder

fn from(val: Table) -> Self

Converts to this type from the input type.

impl<T> FromIterator<T> for Table

where T: IntoIterator, T::Item: Into<String>,

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

impl PartialEq for Table

fn eq(&self, other: &Table) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Table

impl StructuralEq for Table

impl StructuralPartialEq for Table