Struct Table

pub struct Table { /* private fields */ }

An owned printable table

Implementations

impl Table

pub fn from_csv_string(csv_s: &str) -> Result<Self>

Create a table from a CSV string

For more customisability use from_csv()

Examples found in repository

examples/csv.rs (lines 19-23)

fn main() {
    use prettytable::Table;

    let table = Table::from_csv_string(
        "ABC,DEFG,HIJKLMN\n\
                                        foobar,bar,foo\n\
                                        foobar2,bar2,foo2",
    )
    .unwrap();
    table.printstd();

    println!("");
    println!(
        "{}",
        String::from_utf8(table.to_csv(Vec::new()).unwrap().into_inner().unwrap()).unwrap()
    );
}

pub fn from_csv_file<P: AsRef<Path>>(csv_p: P) -> Result<Self>

Create a table from a CSV file

For more customisability use from_csv()

pub fn from_csv<R: Read>(reader: &mut Reader<R>) -> Self

Create a table from a CSV reader

pub fn to_csv<W: Write>(&self, w: W) -> Result<Writer<W>>

Write the table to the specified writer.

Examples found in repository

examples/csv.rs (line 30)

fn main() {
    use prettytable::Table;

    let table = Table::from_csv_string(
        "ABC,DEFG,HIJKLMN\n\
                                        foobar,bar,foo\n\
                                        foobar2,bar2,foo2",
    )
    .unwrap();
    table.printstd();

    println!("");
    println!(
        "{}",
        String::from_utf8(table.to_csv(Vec::new()).unwrap().into_inner().unwrap()).unwrap()
    );
}

pub fn to_csv_writer<W: Write>(&self, writer: Writer<W>) -> Result<Writer<W>>

Write the table to the specified writer.

This allows for format customisation.

impl Table

pub fn new() -> Table

Create an empty table

Examples found in repository

examples/basic.rs (line 22)

fn main() {
    let mut table = Table::new();
    table.add_row(row!["ABC", "DEFG", "HIJKLMN"]);
    table.add_row(row!["foobar", "bar", "foo"]);
    table.add_row(Row::new(vec![
        Cell::new("foobar2"),
        Cell::new("bar2"),
        Cell::new("foo2"),
    ]));
    table.printstd();
    println!("Modified : ");
    table.set_element("new_foo", 2, 1).unwrap();
    table.printstd();

    // The same table can be built the following way :
    let _table = table!(
        ["ABC", "DEFG", "HIJKLMN"],
        ["foobar", "bar", "foo"],
        ["foobar2", "bar2", "foo2"]
    );

    // Or directly print it like this
    let _table = ptable!(
        ["ABC", "DEFG", "HIJKLMN"],
        ["foobar", "bar", "foo"],
        ["foobar2", "bar2", "foo2"]
    );
}

examples/style.rs (line 8)

fn main() {
    let _ = table!();
    let mut table = Table::new();
    // Add style to a cell
    table.add_row(row![FrByb->"ABC", "DEFG", "HIJKLMN"]);
    // Add style to a full row
    table.add_row(row![FY => "styled", "bar", "foo"]);
    table.add_row(Row::new(vec![
        Cell::new("foobar2"),
        // Create a cell with a red foreground color
        Cell::new("bar2").with_style(Attr::ForegroundColor(color::RED)),
        // Create a cell with red foreground color, yellow background color, with bold characters
        Cell::new("foo2").style_spec("FrByb"),
        // Using the cell! macro
        cell!(Fr->"red"),
    ]));

    table.printstd();

    // Print a table with some styles on it :
    // FrBybl means : Foregound red, Background yellow, bold, left align
    ptable!([FrBybl->"A", "B", FrBybr->"C"], [123, 234, 345, 456], [Fg => 1, 2, 3]);

    // You can also apply style to full rows :
    let mut table = table!([Frb => "A", "B", "C"], [1, 2, 3, 4], ["A\nBCCZZZ\nDDD", 2, table]);
    // Set a title line, with all text centered in the cell
    table.set_titles(row![c => "Title 1", "Title 2"]);
    table.printstd();
}

pub fn init(rows: Vec<Row>) -> Table

Create a table initialized with rows

pub fn set_format(&mut self, format: TableFormat)

Change the table format. Eg : Separators

Examples found in repository

examples/formatting.rs (line 15)

fn main() {
    let mut table = table!(["Value 1", "Value 2"], ["Value three", "Value four"]);
    table.set_titles(row!["Title 1", "Title 2"]);

    // Print
    // +-------------+------------+
    // | Title 1     | Title 2    |
    // +-------------+------------+
    // | Value 1     | Value 2    |
    // | Value three | Value four |
    // +-------------+------------+
    println!("FORMAT_NO_LINESEP_WITH_TITLE :");
    table.set_format(*format::consts::FORMAT_NO_LINESEP_WITH_TITLE);
    table.printstd();
    println!("");

    // Print
    // -------------------------
    //  Title 1      Title 2
    // =========================
    //  Value 1      Value 2
    // -------------------------
    //  Value three  Value four
    // -------------------------
    println!("FORMAT_NO_COLSEP :");
    table.set_format(*format::consts::FORMAT_NO_COLSEP);
    table.printstd();
    println!("");

    // Print
    // +-------------------------+
    // | Title 1      Title 2    |
    // +=========================+
    // | Value 1      Value 2    |
    // | Value three  Value four |
    // +-------------------------+
    println!("FORMAT_BORDERS_ONLY :");
    table.set_format(*format::consts::FORMAT_BORDERS_ONLY);
    table.printstd();
    println!("");

    // Custom format can be implemented using `prettytable::format::FormatBuilder`
    // Example to print
    // +-------------+------------+
    // | Title 1     | Title 2    |
    // | Value 1     | Value 2    |
    // | Value three | Value four |
    // +-------------+------------+
    println!("Custom :");
    table.set_format(
        format::FormatBuilder::new()
            .column_separator('|')
            .borders('|')
            .separators(
                &[format::LinePosition::Top, format::LinePosition::Bottom],
                format::LineSeparator::new('-', '+', '+', '+'),
            )
            .padding(1, 1)
            .build(),
    );
    table.printstd();

    // Customized format with unicode
    // Example to print
    // ┌─────────────┬────────────┐
    // │ Title 1     │ Title 2    │
    // ├─────────────┼────────────┤
    // │ Value 1     │ Value 2    │
    // ├─────────────┼────────────┤
    // │ Value three │ Value four │
    // └─────────────┴────────────┘
    println!("With unicode:");
    table.set_format(
        format::FormatBuilder::new()
            .column_separator('│')
            .borders('│')
            .separators(
                &[format::LinePosition::Top],
                format::LineSeparator::new('─', '┬', '┌', '┐'),
            )
            .separators(
                &[format::LinePosition::Intern],
                format::LineSeparator::new('─', '┼', '├', '┤'),
            )
            .separators(
                &[format::LinePosition::Bottom],
                format::LineSeparator::new('─', '┴', '└', '┘'),
            )
            .padding(1, 1)
            .build(),
    );
    table.printstd();

    // Customized format with unicode and different padding
    // Example to print
    // ┌───────────────┬──────────────┐
    // │  Title 1      │  Title 2     │
    // ├───────────────┼──────────────┤
    // │  Value 1      │  Value 2     │
    // ├───────────────┼──────────────┤
    // │  Value three  │  Value four  │
    // └───────────────┴──────────────┘
    // Change individual format settings
    println!("With unicode and padding:");
    table.get_format().padding(2, 2);
    table.printstd();
}

pub fn get_format(&mut self) -> &mut TableFormat

Get a mutable reference to the internal format

Examples found in repository

examples/formatting.rs (line 107)

fn main() {
    let mut table = table!(["Value 1", "Value 2"], ["Value three", "Value four"]);
    table.set_titles(row!["Title 1", "Title 2"]);

    // Print
    // +-------------+------------+
    // | Title 1     | Title 2    |
    // +-------------+------------+
    // | Value 1     | Value 2    |
    // | Value three | Value four |
    // +-------------+------------+
    println!("FORMAT_NO_LINESEP_WITH_TITLE :");
    table.set_format(*format::consts::FORMAT_NO_LINESEP_WITH_TITLE);
    table.printstd();
    println!("");

    // Print
    // -------------------------
    //  Title 1      Title 2
    // =========================
    //  Value 1      Value 2
    // -------------------------
    //  Value three  Value four
    // -------------------------
    println!("FORMAT_NO_COLSEP :");
    table.set_format(*format::consts::FORMAT_NO_COLSEP);
    table.printstd();
    println!("");

    // Print
    // +-------------------------+
    // | Title 1      Title 2    |
    // +=========================+
    // | Value 1      Value 2    |
    // | Value three  Value four |
    // +-------------------------+
    println!("FORMAT_BORDERS_ONLY :");
    table.set_format(*format::consts::FORMAT_BORDERS_ONLY);
    table.printstd();
    println!("");

    // Custom format can be implemented using `prettytable::format::FormatBuilder`
    // Example to print
    // +-------------+------------+
    // | Title 1     | Title 2    |
    // | Value 1     | Value 2    |
    // | Value three | Value four |
    // +-------------+------------+
    println!("Custom :");
    table.set_format(
        format::FormatBuilder::new()
            .column_separator('|')
            .borders('|')
            .separators(
                &[format::LinePosition::Top, format::LinePosition::Bottom],
                format::LineSeparator::new('-', '+', '+', '+'),
            )
            .padding(1, 1)
            .build(),
    );
    table.printstd();

    // Customized format with unicode
    // Example to print
    // ┌─────────────┬────────────┐
    // │ Title 1     │ Title 2    │
    // ├─────────────┼────────────┤
    // │ Value 1     │ Value 2    │
    // ├─────────────┼────────────┤
    // │ Value three │ Value four │
    // └─────────────┴────────────┘
    println!("With unicode:");
    table.set_format(
        format::FormatBuilder::new()
            .column_separator('│')
            .borders('│')
            .separators(
                &[format::LinePosition::Top],
                format::LineSeparator::new('─', '┬', '┌', '┐'),
            )
            .separators(
                &[format::LinePosition::Intern],
                format::LineSeparator::new('─', '┼', '├', '┤'),
            )
            .separators(
                &[format::LinePosition::Bottom],
                format::LineSeparator::new('─', '┴', '└', '┘'),
            )
            .padding(1, 1)
            .build(),
    );
    table.printstd();

    // Customized format with unicode and different padding
    // Example to print
    // ┌───────────────┬──────────────┐
    // │  Title 1      │  Title 2     │
    // ├───────────────┼──────────────┤
    // │  Value 1      │  Value 2     │
    // ├───────────────┼──────────────┤
    // │  Value three  │  Value four  │
    // └───────────────┴──────────────┘
    // Change individual format settings
    println!("With unicode and padding:");
    table.get_format().padding(2, 2);
    table.printstd();
}

pub fn len(&self) -> usize

Get the number of rows

pub fn is_empty(&self) -> bool

Check if the table is empty

pub fn set_titles(&mut self, titles: Row)

Set the optional title lines

Examples found in repository

examples/slices.rs (line 12)

fn main() {
    let mut table = table![
        [0, 0, 0],
        [1, 1, 1],
        [2, 2, 2],
        [3, 3, 3],
        [4, 4, 4],
        [5, 5, 5]
    ];
    table.set_titles(row!["t1", "t2", "t3"]);

    let slice = table.slice(..);
    let slice = slice.slice(2..);
    let slice = slice.slice(..3);

    /*
        Will print
        +----+----+----+
        | t1 | t2 | t3 |
        +====+====+====+
        | 2  | 2  | 2  |
        +----+----+----+
        | 3  | 3  | 3  |
        +----+----+----+
        | 4  | 4  | 4  |
        +----+----+----+
    */
    slice.printstd();

    // This is equivalent to
    let slice = table.slice(2..5);
    slice.printstd();
}

examples/span.rs (lines 23-27)

fn main() {
    /*
        The following code will output

        +---------------+---------------+--------------+
        |         A table with horizontal span         |
        +===============+===============+==============+
        | This is a cell with span of 2 | span of 1    |
        +---------------+---------------+--------------+
        | span of 1     | span of 1     | span of 1    |
        +---------------+---------------+--------------+
        |    This cell with a span of 3 is centered    |
        +---------------+---------------+--------------+
    */

    let mut table: prettytable::Table = table![
    [H2 -> "This is a cell with span of 2", "span of 1"],
    ["span of 1", "span of 1", "span of 1"],
    [H03c -> "This cell with a span of 3 is centered"]
    ];
    table.set_titles(Row::new(vec![Cell::new_align(
        "A table with horizontal span",
        Alignment::CENTER,
    )
    .with_hspan(3)]));
    table.printstd();
}

examples/style.rs (line 32)

fn main() {
    let _ = table!();
    let mut table = Table::new();
    // Add style to a cell
    table.add_row(row![FrByb->"ABC", "DEFG", "HIJKLMN"]);
    // Add style to a full row
    table.add_row(row![FY => "styled", "bar", "foo"]);
    table.add_row(Row::new(vec![
        Cell::new("foobar2"),
        // Create a cell with a red foreground color
        Cell::new("bar2").with_style(Attr::ForegroundColor(color::RED)),
        // Create a cell with red foreground color, yellow background color, with bold characters
        Cell::new("foo2").style_spec("FrByb"),
        // Using the cell! macro
        cell!(Fr->"red"),
    ]));

    table.printstd();

    // Print a table with some styles on it :
    // FrBybl means : Foregound red, Background yellow, bold, left align
    ptable!([FrBybl->"A", "B", FrBybr->"C"], [123, 234, 345, 456], [Fg => 1, 2, 3]);

    // You can also apply style to full rows :
    let mut table = table!([Frb => "A", "B", "C"], [1, 2, 3, 4], ["A\nBCCZZZ\nDDD", 2, table]);
    // Set a title line, with all text centered in the cell
    table.set_titles(row![c => "Title 1", "Title 2"]);
    table.printstd();
}

examples/formatting.rs (line 5)

fn main() {
    let mut table = table!(["Value 1", "Value 2"], ["Value three", "Value four"]);
    table.set_titles(row!["Title 1", "Title 2"]);

    // Print
    // +-------------+------------+
    // | Title 1     | Title 2    |
    // +-------------+------------+
    // | Value 1     | Value 2    |
    // | Value three | Value four |
    // +-------------+------------+
    println!("FORMAT_NO_LINESEP_WITH_TITLE :");
    table.set_format(*format::consts::FORMAT_NO_LINESEP_WITH_TITLE);
    table.printstd();
    println!("");

    // Print
    // -------------------------
    //  Title 1      Title 2
    // =========================
    //  Value 1      Value 2
    // -------------------------
    //  Value three  Value four
    // -------------------------
    println!("FORMAT_NO_COLSEP :");
    table.set_format(*format::consts::FORMAT_NO_COLSEP);
    table.printstd();
    println!("");

    // Print
    // +-------------------------+
    // | Title 1      Title 2    |
    // +=========================+
    // | Value 1      Value 2    |
    // | Value three  Value four |
    // +-------------------------+
    println!("FORMAT_BORDERS_ONLY :");
    table.set_format(*format::consts::FORMAT_BORDERS_ONLY);
    table.printstd();
    println!("");

    // Custom format can be implemented using `prettytable::format::FormatBuilder`
    // Example to print
    // +-------------+------------+
    // | Title 1     | Title 2    |
    // | Value 1     | Value 2    |
    // | Value three | Value four |
    // +-------------+------------+
    println!("Custom :");
    table.set_format(
        format::FormatBuilder::new()
            .column_separator('|')
            .borders('|')
            .separators(
                &[format::LinePosition::Top, format::LinePosition::Bottom],
                format::LineSeparator::new('-', '+', '+', '+'),
            )
            .padding(1, 1)
            .build(),
    );
    table.printstd();

    // Customized format with unicode
    // Example to print
    // ┌─────────────┬────────────┐
    // │ Title 1     │ Title 2    │
    // ├─────────────┼────────────┤
    // │ Value 1     │ Value 2    │
    // ├─────────────┼────────────┤
    // │ Value three │ Value four │
    // └─────────────┴────────────┘
    println!("With unicode:");
    table.set_format(
        format::FormatBuilder::new()
            .column_separator('│')
            .borders('│')
            .separators(
                &[format::LinePosition::Top],
                format::LineSeparator::new('─', '┬', '┌', '┐'),
            )
            .separators(
                &[format::LinePosition::Intern],
                format::LineSeparator::new('─', '┼', '├', '┤'),
            )
            .separators(
                &[format::LinePosition::Bottom],
                format::LineSeparator::new('─', '┴', '└', '┘'),
            )
            .padding(1, 1)
            .build(),
    );
    table.printstd();

    // Customized format with unicode and different padding
    // Example to print
    // ┌───────────────┬──────────────┐
    // │  Title 1      │  Title 2     │
    // ├───────────────┼──────────────┤
    // │  Value 1      │  Value 2     │
    // ├───────────────┼──────────────┤
    // │  Value three  │  Value four  │
    // └───────────────┴──────────────┘
    // Change individual format settings
    println!("With unicode and padding:");
    table.get_format().padding(2, 2);
    table.printstd();
}

pub fn unset_titles(&mut self)

Unset the title line

pub fn get_mut_row(&mut self, row: usize) -> Option<&mut Row>

Get a mutable reference to a row

Examples found in repository

examples/tictactoe.rs (line 44)

fn main() {
    let mut table = table![
        [EMPTY, EMPTY, EMPTY],
        [EMPTY, EMPTY, EMPTY],
        [EMPTY, EMPTY, EMPTY]
    ];
    let mut height = table.print_tty(false).unwrap();
    let stdin = io::stdin();
    let mut stdout = io::stdout();
    let mut current = CROSS;
    let mut terminal = term::stdout().unwrap();
    loop {
        let mut line = String::new();
        print!("{} plays > ", current);
        height += 1;
        stdout.flush().unwrap();
        stdin.read_line(&mut line).expect("Cannot read input");
        let i = match usize::from_str(line.trim()) {
            Ok(i) => i,
            _ => {
                println!("Bad input");
                height += 1;
                continue;
            }
        };
        if i < 1 || i > 9 {
            println!("Bad input, should be between 1 and 9");
            height += 1;
            continue;
        }
        let x = (i - 1) % 3;
        let y = (i - 1) / 3;
        {
            let row = table.get_mut_row(y).unwrap();
            if row.get_cell(x).unwrap().to_string() != EMPTY {
                println!("There's already someone there");
                height += 1;
                continue;
            }
            row.set_cell(cell!(current), x).unwrap();
        }
        for _ in 0..height {
            terminal.cursor_up().unwrap();
            terminal.delete_line().unwrap();
        }
        height = table.print_tty(false).unwrap();
        if check(&table) {
            return;
        }
        if current == CROSS {
            current = ROUND;
        } else {
            current = CROSS;
        }
    }
}

pub fn get_row(&self, row: usize) -> Option<&Row>

Get an immutable reference to a row

Examples found in repository

examples/tictactoe.rs (line 69)

fn get(table: &Table, x: usize, y: usize) -> String {
    match table.get_row(y) {
        Some(r) => match r.get_cell(x) {
            Some(c) => c.to_string(),
            _ => EMPTY.to_string(),
        },
        _ => EMPTY.to_string(),
    }
}

pub fn add_row(&mut self, row: Row) -> &mut Row

Append a row in the table, transferring ownership of this row to the table and returning a mutable reference to the row

Examples found in repository

examples/basic.rs (line 23)

fn main() {
    let mut table = Table::new();
    table.add_row(row!["ABC", "DEFG", "HIJKLMN"]);
    table.add_row(row!["foobar", "bar", "foo"]);
    table.add_row(Row::new(vec![
        Cell::new("foobar2"),
        Cell::new("bar2"),
        Cell::new("foo2"),
    ]));
    table.printstd();
    println!("Modified : ");
    table.set_element("new_foo", 2, 1).unwrap();
    table.printstd();

    // The same table can be built the following way :
    let _table = table!(
        ["ABC", "DEFG", "HIJKLMN"],
        ["foobar", "bar", "foo"],
        ["foobar2", "bar2", "foo2"]
    );

    // Or directly print it like this
    let _table = ptable!(
        ["ABC", "DEFG", "HIJKLMN"],
        ["foobar", "bar", "foo"],
        ["foobar2", "bar2", "foo2"]
    );
}

examples/style.rs (line 10)

fn main() {
    let _ = table!();
    let mut table = Table::new();
    // Add style to a cell
    table.add_row(row![FrByb->"ABC", "DEFG", "HIJKLMN"]);
    // Add style to a full row
    table.add_row(row![FY => "styled", "bar", "foo"]);
    table.add_row(Row::new(vec![
        Cell::new("foobar2"),
        // Create a cell with a red foreground color
        Cell::new("bar2").with_style(Attr::ForegroundColor(color::RED)),
        // Create a cell with red foreground color, yellow background color, with bold characters
        Cell::new("foo2").style_spec("FrByb"),
        // Using the cell! macro
        cell!(Fr->"red"),
    ]));

    table.printstd();

    // Print a table with some styles on it :
    // FrBybl means : Foregound red, Background yellow, bold, left align
    ptable!([FrBybl->"A", "B", FrBybr->"C"], [123, 234, 345, 456], [Fg => 1, 2, 3]);

    // You can also apply style to full rows :
    let mut table = table!([Frb => "A", "B", "C"], [1, 2, 3, 4], ["A\nBCCZZZ\nDDD", 2, table]);
    // Set a title line, with all text centered in the cell
    table.set_titles(row![c => "Title 1", "Title 2"]);
    table.printstd();
}

pub fn add_empty_row(&mut self) -> &mut Row

Append an empty row in the table. Return a mutable reference to this new row.

pub fn insert_row(&mut self, index: usize, row: Row) -> &mut Row

Insert row at the position index, and return a mutable reference to this row. If index is higher than current numbers of rows, row is appended at the end of the table

pub fn set_element( &mut self, element: &str, column: usize, row: usize, ) -> Result<(), &str>

Modify a single element in the table

Examples found in repository

examples/basic.rs (line 32)

fn main() {
    let mut table = Table::new();
    table.add_row(row!["ABC", "DEFG", "HIJKLMN"]);
    table.add_row(row!["foobar", "bar", "foo"]);
    table.add_row(Row::new(vec![
        Cell::new("foobar2"),
        Cell::new("bar2"),
        Cell::new("foo2"),
    ]));
    table.printstd();
    println!("Modified : ");
    table.set_element("new_foo", 2, 1).unwrap();
    table.printstd();

    // The same table can be built the following way :
    let _table = table!(
        ["ABC", "DEFG", "HIJKLMN"],
        ["foobar", "bar", "foo"],
        ["foobar2", "bar2", "foo2"]
    );

    // Or directly print it like this
    let _table = ptable!(
        ["ABC", "DEFG", "HIJKLMN"],
        ["foobar", "bar", "foo"],
        ["foobar2", "bar2", "foo2"]
    );
}

pub fn remove_row(&mut self, index: usize)

Remove the row at position index. Silently skip if the row does not exist

pub fn column_iter(&self, column: usize) -> ColumnIter<'_>

Return an iterator over the immutable cells of the column specified by column

pub fn column_iter_mut(&mut self, column: usize) -> ColumnIterMut<'_>

Return an iterator over the mutable cells of the column specified by column

pub fn row_iter(&self) -> Iter<'_, Row>

Returns an iterator over immutable rows

pub fn row_iter_mut(&mut self) -> IterMut<'_, Row>

Returns an iterator over mutable rows

pub fn print<T: Write + ?Sized>(&self, out: &mut T) -> Result<usize, Error>

Print the table to out and returns the number of lines printed, or an error

pub fn print_term<T: Terminal + ?Sized>( &self, out: &mut T, ) -> Result<usize, Error>

Print the table to terminal out, applying styles when needed and returns the number of lines printed, or an error

pub fn print_tty(&self, force_colorize: bool) -> Result<usize, Error>

Print the table to standard output. Colors won’t be displayed unless stdout is a tty terminal, or force_colorize is set to true. In ANSI terminals, colors are displayed using ANSI escape characters. When for example the output is redirected to a file, or piped to another program, the output is considered as not beeing tty, and ANSI escape characters won’t be displayed unless force colorize is set to true.

Returns

A Result holding the number of lines printed, or an io::Error if any failure happens

Examples found in repository

examples/tictactoe.rs (line 17)

fn main() {
    let mut table = table![
        [EMPTY, EMPTY, EMPTY],
        [EMPTY, EMPTY, EMPTY],
        [EMPTY, EMPTY, EMPTY]
    ];
    let mut height = table.print_tty(false).unwrap();
    let stdin = io::stdin();
    let mut stdout = io::stdout();
    let mut current = CROSS;
    let mut terminal = term::stdout().unwrap();
    loop {
        let mut line = String::new();
        print!("{} plays > ", current);
        height += 1;
        stdout.flush().unwrap();
        stdin.read_line(&mut line).expect("Cannot read input");
        let i = match usize::from_str(line.trim()) {
            Ok(i) => i,
            _ => {
                println!("Bad input");
                height += 1;
                continue;
            }
        };
        if i < 1 || i > 9 {
            println!("Bad input, should be between 1 and 9");
            height += 1;
            continue;
        }
        let x = (i - 1) % 3;
        let y = (i - 1) / 3;
        {
            let row = table.get_mut_row(y).unwrap();
            if row.get_cell(x).unwrap().to_string() != EMPTY {
                println!("There's already someone there");
                height += 1;
                continue;
            }
            row.set_cell(cell!(current), x).unwrap();
        }
        for _ in 0..height {
            terminal.cursor_up().unwrap();
            terminal.delete_line().unwrap();
        }
        height = table.print_tty(false).unwrap();
        if check(&table) {
            return;
        }
        if current == CROSS {
            current = ROUND;
        } else {
            current = CROSS;
        }
    }
}

pub fn printstd(&self)

Print the table to standard output. Colors won’t be displayed unless stdout is a tty terminal. This means that if stdout is redirected to a file, or piped to another program, no color will be displayed. To force colors rendering, use print_tty() method. Any failure to print is ignored. For better control, use print_tty(). Calling printstd() is equivalent to calling print_tty(false) and ignoring the result.

Examples found in repository

examples/multiline.rs (line 31)

fn main() {
    let table1 = table!(
        ["ABC", "DEFG", "HIJKLMN"],
        ["foobar", "bar", "foo"],
        ["foobar2", "bar2", "foo2"]
    );
    let table2 = table!(
        ["Title 1", "Title 2"],
        ["This is\na multiline\ncell", "foo"],
        ["Yo dawg ;) You can even\nprint tables\ninto tables", table1]
    );
    table2.printstd();
}

examples/csv.rs (line 25)

fn main() {
    use prettytable::Table;

    let table = Table::from_csv_string(
        "ABC,DEFG,HIJKLMN\n\
                                        foobar,bar,foo\n\
                                        foobar2,bar2,foo2",
    )
    .unwrap();
    table.printstd();

    println!("");
    println!(
        "{}",
        String::from_utf8(table.to_csv(Vec::new()).unwrap().into_inner().unwrap()).unwrap()
    );
}

examples/basic.rs (line 30)

fn main() {
    let mut table = Table::new();
    table.add_row(row!["ABC", "DEFG", "HIJKLMN"]);
    table.add_row(row!["foobar", "bar", "foo"]);
    table.add_row(Row::new(vec![
        Cell::new("foobar2"),
        Cell::new("bar2"),
        Cell::new("foo2"),
    ]));
    table.printstd();
    println!("Modified : ");
    table.set_element("new_foo", 2, 1).unwrap();
    table.printstd();

    // The same table can be built the following way :
    let _table = table!(
        ["ABC", "DEFG", "HIJKLMN"],
        ["foobar", "bar", "foo"],
        ["foobar2", "bar2", "foo2"]
    );

    // Or directly print it like this
    let _table = ptable!(
        ["ABC", "DEFG", "HIJKLMN"],
        ["foobar", "bar", "foo"],
        ["foobar2", "bar2", "foo2"]
    );
}

examples/span.rs (line 28)

fn main() {
    /*
        The following code will output

        +---------------+---------------+--------------+
        |         A table with horizontal span         |
        +===============+===============+==============+
        | This is a cell with span of 2 | span of 1    |
        +---------------+---------------+--------------+
        | span of 1     | span of 1     | span of 1    |
        +---------------+---------------+--------------+
        |    This cell with a span of 3 is centered    |
        +---------------+---------------+--------------+
    */

    let mut table: prettytable::Table = table![
    [H2 -> "This is a cell with span of 2", "span of 1"],
    ["span of 1", "span of 1", "span of 1"],
    [H03c -> "This cell with a span of 3 is centered"]
    ];
    table.set_titles(Row::new(vec![Cell::new_align(
        "A table with horizontal span",
        Alignment::CENTER,
    )
    .with_hspan(3)]));
    table.printstd();
}

examples/style.rs (line 23)

fn main() {
    let _ = table!();
    let mut table = Table::new();
    // Add style to a cell
    table.add_row(row![FrByb->"ABC", "DEFG", "HIJKLMN"]);
    // Add style to a full row
    table.add_row(row![FY => "styled", "bar", "foo"]);
    table.add_row(Row::new(vec![
        Cell::new("foobar2"),
        // Create a cell with a red foreground color
        Cell::new("bar2").with_style(Attr::ForegroundColor(color::RED)),
        // Create a cell with red foreground color, yellow background color, with bold characters
        Cell::new("foo2").style_spec("FrByb"),
        // Using the cell! macro
        cell!(Fr->"red"),
    ]));

    table.printstd();

    // Print a table with some styles on it :
    // FrBybl means : Foregound red, Background yellow, bold, left align
    ptable!([FrBybl->"A", "B", FrBybr->"C"], [123, 234, 345, 456], [Fg => 1, 2, 3]);

    // You can also apply style to full rows :
    let mut table = table!([Frb => "A", "B", "C"], [1, 2, 3, 4], ["A\nBCCZZZ\nDDD", 2, table]);
    // Set a title line, with all text centered in the cell
    table.set_titles(row![c => "Title 1", "Title 2"]);
    table.printstd();
}

examples/formatting.rs (line 16)

fn main() {
    let mut table = table!(["Value 1", "Value 2"], ["Value three", "Value four"]);
    table.set_titles(row!["Title 1", "Title 2"]);

    // Print
    // +-------------+------------+
    // | Title 1     | Title 2    |
    // +-------------+------------+
    // | Value 1     | Value 2    |
    // | Value three | Value four |
    // +-------------+------------+
    println!("FORMAT_NO_LINESEP_WITH_TITLE :");
    table.set_format(*format::consts::FORMAT_NO_LINESEP_WITH_TITLE);
    table.printstd();
    println!("");

    // Print
    // -------------------------
    //  Title 1      Title 2
    // =========================
    //  Value 1      Value 2
    // -------------------------
    //  Value three  Value four
    // -------------------------
    println!("FORMAT_NO_COLSEP :");
    table.set_format(*format::consts::FORMAT_NO_COLSEP);
    table.printstd();
    println!("");

    // Print
    // +-------------------------+
    // | Title 1      Title 2    |
    // +=========================+
    // | Value 1      Value 2    |
    // | Value three  Value four |
    // +-------------------------+
    println!("FORMAT_BORDERS_ONLY :");
    table.set_format(*format::consts::FORMAT_BORDERS_ONLY);
    table.printstd();
    println!("");

    // Custom format can be implemented using `prettytable::format::FormatBuilder`
    // Example to print
    // +-------------+------------+
    // | Title 1     | Title 2    |
    // | Value 1     | Value 2    |
    // | Value three | Value four |
    // +-------------+------------+
    println!("Custom :");
    table.set_format(
        format::FormatBuilder::new()
            .column_separator('|')
            .borders('|')
            .separators(
                &[format::LinePosition::Top, format::LinePosition::Bottom],
                format::LineSeparator::new('-', '+', '+', '+'),
            )
            .padding(1, 1)
            .build(),
    );
    table.printstd();

    // Customized format with unicode
    // Example to print
    // ┌─────────────┬────────────┐
    // │ Title 1     │ Title 2    │
    // ├─────────────┼────────────┤
    // │ Value 1     │ Value 2    │
    // ├─────────────┼────────────┤
    // │ Value three │ Value four │
    // └─────────────┴────────────┘
    println!("With unicode:");
    table.set_format(
        format::FormatBuilder::new()
            .column_separator('│')
            .borders('│')
            .separators(
                &[format::LinePosition::Top],
                format::LineSeparator::new('─', '┬', '┌', '┐'),
            )
            .separators(
                &[format::LinePosition::Intern],
                format::LineSeparator::new('─', '┼', '├', '┤'),
            )
            .separators(
                &[format::LinePosition::Bottom],
                format::LineSeparator::new('─', '┴', '└', '┘'),
            )
            .padding(1, 1)
            .build(),
    );
    table.printstd();

    // Customized format with unicode and different padding
    // Example to print
    // ┌───────────────┬──────────────┐
    // │  Title 1      │  Title 2     │
    // ├───────────────┼──────────────┤
    // │  Value 1      │  Value 2     │
    // ├───────────────┼──────────────┤
    // │  Value three  │  Value four  │
    // └───────────────┴──────────────┘
    // Change individual format settings
    println!("With unicode and padding:");
    table.get_format().padding(2, 2);
    table.printstd();
}

pub fn print_html<T: Write + ?Sized>(&self, out: &mut T) -> Result<(), Error>

Print table in HTML format to out.

Trait Implementations

impl AsTableSlice for Table

fn as_slice(&self) -> TableSlice<'_>

Get a slice from self

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() -> Table

Returns the “default value” for a type.

impl Display for Table

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

Formats the value using the given formatter.

impl<A: Into<Row>> Extend<A> for Table

fn extend<T: IntoIterator<Item = A>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T, A, B> From<T> for Table

where B: ToString, A: IntoIterator<Item = B>, T: IntoIterator<Item = A>,

fn from(it: T) -> Table

Converts to this type from the input type.

impl<B: ToString, A: IntoIterator<Item = B>> FromIterator<A> for Table

fn from_iter<T>(iterator: T) -> Table

where T: IntoIterator<Item = A>,

Creates a value from an iterator.

impl FromIterator<Row> for Table

fn from_iter<T>(iterator: T) -> Table

where T: IntoIterator<Item = Row>,

Creates a value from an iterator.

impl Hash for Table

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Index<usize> for Table

type Output = Row

The returned type after indexing.

fn index(&self, idx: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IndexMut<usize> for Table

fn index_mut(&mut self, idx: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a> IntoIterator for &'a Table

type Item = &'a Row

The type of the elements being iterated over.

type IntoIter = Iter<'a, Row>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &'a mut Table

type Item = &'a mut Row

The type of the elements being iterated over.

type IntoIter = IterMut<'a, Row>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for Table

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for Table

impl StructuralPartialEq for Table