Enum Cell 

pub enum Cell<'a> {
    Int(i32),
    Float(f64),
    Text(Box<dyn Unstyle + 'a>),
}

The content of each cell of the table (either a string or a number)

Variants

Int(i32)

Integer variant

Float(f64)

Float variant

Text(Box<dyn Unstyle + 'a>)

Unstylable Text variant

Implementations

impl<'a> Cell<'a>

pub fn from(s: &str) -> Self

Creates a Text Cell from a simple &str

Warning

If the given &str contains ASCII escape sequences, they will mess with the generated layout. Use a Box<dyn Unstyle> like AsciiEscapedString.

Examples found in repository

examples/wide_characters.rs (line 8)

fn main() {
    // Wide characters are handled correctly when computing columns length:
    let table = Table::new(
        Style::Grid,
        vec![
            vec![Cell::from("Tabulate with style!")],
            vec![Cell::from("табулировать со стилем!")],
            vec![Cell::from("スタイルで集計！")],
            vec![Cell::from("用样式表！")],
        ],
        None,
    );
    println!("{}", table.tabulate());
    /* Will print:
    +-------------------------+
    | Tabulate with style!    |
    +-------------------------+
    | табулировать со стилем! |
    +-------------------------+
    | スタイルで集計！        |
    +-------------------------+
    | 用样式表！              |
    +-------------------------+
    */
}

examples/simple.rs (line 8)

fn main() {
    // A simple table with strings and numbers and the default alignments
    let mut table = Table::new(
        Style::Fancy,
        vec![
            vec![Cell::from("spam"), Cell::Float(41.9999)],
            vec![Cell::from("eggs"), Cell::Int(451)],
        ],
        Some(Headers::from(vec!["strings", "numbers"])),
    );
    println!("{}", table.tabulate());
    /* Will print:
    ╒═══════════╤═══════════╕
    │ strings   │   numbers │
    ╞═══════════╪═══════════╡
    │ spam      │   41.9999 │
    ├───────────┼───────────┤
    │ eggs      │  451      │
    ╘═══════════╧═══════════╛
    */

    // Alignment can be changed like so:
    table.set_align(Align::Right, Align::Center);
    println!("{}", table.tabulate());
    /* Will print:
    ╒═══════════╤═══════════╕
    │   strings │  numbers  │
    ╞═══════════╪═══════════╡
    │      spam │  41.9999  │
    ├───────────┼───────────┤
    │      eggs │ 451.0000  │
    ╘═══════════╧═══════════╛
    */

    // With the feature "ansi_term_style", the borders style can be changed like so:
    table.set_border_style(ansi_term::Color::Cyan.bold());
    println!("{}", table.tabulate());
    // Will print same as above but with bold and colored borders
}

examples/colored_content.rs (line 8)

fn main() {
    // Colored content can be inserted either with AsciiEscapedString
    let table = Table::new(
        Style::Presto,
        vec![
            vec![Cell::from("Normal"), Cell::from("Stybulate")],
            vec![
                Cell::from("Red"),
                Cell::Text(Box::new(AsciiEscapedString::from(
                    "\x1b[31mStybulate\x1b[0m",
                ))),
            ],
            vec![
                Cell::from("Green"),
                Cell::Text(Box::new(AsciiEscapedString::from(
                    "\x1b[32mStybulate\x1b[0m",
                ))),
            ],
            vec![
                Cell::from("Yellow"),
                Cell::Text(Box::new(AsciiEscapedString::from(
                    "\x1b[33mStybulate\x1b[0m",
                ))),
            ],
            vec![
                Cell::from("Blue"),
                Cell::Text(Box::new(AsciiEscapedString::from(
                    "\x1b[34mStybulate\x1b[0m",
                ))),
            ],
            vec![
                Cell::from("Mutlicolor and blinking (because why not?)"),
                Cell::Text(Box::new(AsciiEscapedString::from(
                    "\x1b[5;30mS\x1b[31mt\x1b[32my\x1b[33mb\x1b[34mu\x1b[35ml\x1b[36ma\x1b[37mt\x1b[30me\x1b[0m",
                ))),
            ],
        ],
        Some(Headers::from(vec!["Style", "Text"])),
    );
    println!("{}", table.tabulate());

    // or with ansi_term ANSIStrings (with the feature "ansi_term_style")
    use ansi_term::ANSIStrings;
    use ansi_term::Color::*;
    let red_stybulate = &[Red.paint("Stybulate")];
    let green_stybulate = &[Green.paint("Stybulate")];
    let yellow_stybulate = &[Yellow.paint("Stybulate")];
    let blue_stybulate = &[Blue.paint("Stybulate")];
    let multicolorandblinking_stybulate = &[
        Black.blink().paint("S"),
        Red.blink().paint("t"),
        Green.blink().paint("y"),
        Yellow.blink().paint("b"),
        Blue.blink().paint("u"),
        Purple.blink().paint("l"),
        Cyan.blink().paint("a"),
        White.blink().paint("t"),
        Black.blink().paint("e"),
    ];
    let table2 = Table::new(
        Style::FancyGithub,
        vec![
            vec![Cell::from("Normal"), Cell::from("Stybulate")],
            vec![
                Cell::from("Red"),
                Cell::Text(Box::new(ANSIStrings(red_stybulate))),
            ],
            vec![
                Cell::from("Green"),
                Cell::Text(Box::new(ANSIStrings(green_stybulate))),
            ],
            vec![
                Cell::from("Yellow"),
                Cell::Text(Box::new(ANSIStrings(yellow_stybulate))),
            ],
            vec![
                Cell::from("Blue"),
                Cell::Text(Box::new(ANSIStrings(blue_stybulate))),
            ],
            vec![
                Cell::from("Mutlicolor and blinking (because why not?)"),
                Cell::Text(Box::new(ANSIStrings(multicolorandblinking_stybulate))),
            ],
        ],
        Some(Headers::from(vec!["Style", "Text"])),
    );
    println!("{}", table2.tabulate());
}

pub fn is_a_number(&self) -> bool

Is it a number ?

pub fn to_unstylable(&self) -> Option<&Box<dyn Unstyle + 'a>>

Returns the unstylable content if it is a Text Variant, None otherwise

pub fn to_string(&self) -> Option<String>

Returns the string representation of a number, None if it is a Text Variant

pub fn to_string_with_precision(&self, digits: usize) -> Option<String>

Same as to_string but formatted with a precision

pub fn digits_len(&self) -> usize

Number of digits after the dot in a float, 0 otherwise