Struct Table 

pub struct Table { /* private fields */ }

Implementations

impl Table

pub fn new() -> Self

Examples found in repository

examples/table.rs (line 16)

fn demo_styles() {
    // Basic table with Modern style
    println!("=== Modern Style ===");
    let mut table = Table::new();
    table.set_style(TableStyle::Modern);
    table.set_headers(["Name", "Age", "City"]);
    table.add_row(["Kelana", "30", "Berlin"]);
    table.add_row(["Kata", "25", "Yogyakarta"]);
    table.add_row(["Cherry Blossom", "35", "Bikini Bottom"]);
    table.print();

    // Classic style
    println!("\n=== Classic Style ===");
    table.set_style(TableStyle::Classic);
    table.print();

    // Minimal style
    println!("\n=== Minimal Style ===");
    table.set_style(TableStyle::Minimal);
    table.print();

    // Compact style
    println!("\n=== Compact Style ===");
    table.set_style(TableStyle::Compact);
    table.print();

    // Markdown style
    println!("\n=== Markdown Style ===");
    table.set_style(TableStyle::Markdown);
    table.print();
}

fn demo_builder() {
    // Using TableBuilder
    println!("\n=== TableBuilder with Constraints ===");
    TableBuilder::new()
        .style(TableStyle::Modern)
        .header(["ID", "Name", "Score"])
        .constrain(0, WidthConstraint::Fixed(5))
        .constrain(1, WidthConstraint::Min(15))
        .align(2, Alignment::Right)
        .rows([
            ["1", "Kelana", "95.5"],
            ["2", "Kata", "87.2"],
            ["3", "Cherry Blossom", "92.0"],
        ])
        .print();
}

fn demo_colspan() {
    // Colspan example
    println!("\n=== Colspan Example ===");
    let mut table = Table::new();
    table.set_style(TableStyle::Modern);

    // Header row spanning all 5 columns
    let mut header = Row::new();
    let mut title_cell = Cell::new("span all 5 columns", Alignment::Left);
    title_cell.set_span(5);
    header.push(title_cell);
    table.set_headers(header);

    // Row: span 4 columns + 1 column
    let mut row1 = Row::new();
    let mut span4 = Cell::new("span 4 columns", Alignment::Left);
    span4.set_span(4);
    row1.push(span4);
    row1.push(Cell::new("just 1 column", Alignment::Left));
    table.add_row(row1);

    // Row: span 3 columns + span 2 columns
    let mut row2 = Row::new();
    let mut span3_left = Cell::new("span 3 columns", Alignment::Left);
    span3_left.set_span(3);
    row2.push(span3_left);
    let mut span2_right = Cell::new("span 2 columns", Alignment::Left);
    span2_right.set_span(2);
    row2.push(span2_right);
    table.add_row(row2);

    // Row: span 2 columns + span 3 columns
    let mut row3 = Row::new();
    let mut span2_left = Cell::new("span 2 columns", Alignment::Left);
    span2_left.set_span(2);
    row3.push(span2_left);
    let mut span3_right = Cell::new("span 3 columns", Alignment::Left);
    span3_right.set_span(3);
    row3.push(span3_right);
    table.add_row(row3);

    // Row: 1 column + span 4 columns
    let mut row4 = Row::new();
    row4.push(Cell::new("just 1 column", Alignment::Left));
    let mut span4_right = Cell::new("span 4 columns", Alignment::Left);
    span4_right.set_span(4);
    row4.push(span4_right);
    table.add_row(row4);

    // Row: all 5 individual columns
    table.add_row([
        "just 1 column",
        "just 1 column",
        "just 1 column",
        "just 1 column",
        "just 1 column",
    ]);

    table.print();
}

fn demo_invoice() {
    // Invoice style colspan example
    println!("\n=== Invoice Style with Colspan ===");
    let mut invoice = Table::new();
    invoice.set_style(TableStyle::Modern);

    // Invoice header spanning all columns
    let mut inv_header = Row::new();
    let mut inv_title = Cell::new("INVOICE #2024-001", Alignment::Center);
    inv_title.set_span(4);
    inv_header.push(inv_title);
    invoice.set_headers(inv_header);

    // Column headers
    invoice.add_row(Row::with_alignment(
        ["Item", "Qty", "Price", "Total"],
        Alignment::Center,
    ));

    // Line items
    invoice.add_row(["Widget A", "5", "$10", "$50"]);
    invoice.add_row(["Widget B", "3", "$15", "$45"]);
    invoice.add_row(["Service", "1", "$25", "$25"]);

    // Subtotal row
    let mut subtotal = Row::new();
    let mut subtotal_label = Cell::new("Subtotal:", Alignment::Right);
    subtotal_label.set_span(3);
    subtotal.push(subtotal_label);
    subtotal.push(Cell::new("$120", Alignment::Right));
    invoice.add_row(subtotal);

    // Tax row
    let mut tax = Row::new();
    let mut tax_label = Cell::new("Tax (10%):", Alignment::Right);
    tax_label.set_span(3);
    tax.push(tax_label);
    tax.push(Cell::new("$12", Alignment::Right));
    invoice.add_row(tax);

    // Grand total row
    let mut grand_total = Row::new();
    let mut total_label = Cell::new("TOTAL:", Alignment::Right);
    total_label.set_span(3);
    grand_total.push(total_label);
    grand_total.push(Cell::new("$132", Alignment::Right));
    invoice.add_row(grand_total);

    invoice.print();
}

pub fn set_headers<R: Into<Row>>(&mut self, headers: R)

Examples found in repository

examples/table.rs (line 18)

fn demo_styles() {
    // Basic table with Modern style
    println!("=== Modern Style ===");
    let mut table = Table::new();
    table.set_style(TableStyle::Modern);
    table.set_headers(["Name", "Age", "City"]);
    table.add_row(["Kelana", "30", "Berlin"]);
    table.add_row(["Kata", "25", "Yogyakarta"]);
    table.add_row(["Cherry Blossom", "35", "Bikini Bottom"]);
    table.print();

    // Classic style
    println!("\n=== Classic Style ===");
    table.set_style(TableStyle::Classic);
    table.print();

    // Minimal style
    println!("\n=== Minimal Style ===");
    table.set_style(TableStyle::Minimal);
    table.print();

    // Compact style
    println!("\n=== Compact Style ===");
    table.set_style(TableStyle::Compact);
    table.print();

    // Markdown style
    println!("\n=== Markdown Style ===");
    table.set_style(TableStyle::Markdown);
    table.print();
}

fn demo_builder() {
    // Using TableBuilder
    println!("\n=== TableBuilder with Constraints ===");
    TableBuilder::new()
        .style(TableStyle::Modern)
        .header(["ID", "Name", "Score"])
        .constrain(0, WidthConstraint::Fixed(5))
        .constrain(1, WidthConstraint::Min(15))
        .align(2, Alignment::Right)
        .rows([
            ["1", "Kelana", "95.5"],
            ["2", "Kata", "87.2"],
            ["3", "Cherry Blossom", "92.0"],
        ])
        .print();
}

fn demo_colspan() {
    // Colspan example
    println!("\n=== Colspan Example ===");
    let mut table = Table::new();
    table.set_style(TableStyle::Modern);

    // Header row spanning all 5 columns
    let mut header = Row::new();
    let mut title_cell = Cell::new("span all 5 columns", Alignment::Left);
    title_cell.set_span(5);
    header.push(title_cell);
    table.set_headers(header);

    // Row: span 4 columns + 1 column
    let mut row1 = Row::new();
    let mut span4 = Cell::new("span 4 columns", Alignment::Left);
    span4.set_span(4);
    row1.push(span4);
    row1.push(Cell::new("just 1 column", Alignment::Left));
    table.add_row(row1);

    // Row: span 3 columns + span 2 columns
    let mut row2 = Row::new();
    let mut span3_left = Cell::new("span 3 columns", Alignment::Left);
    span3_left.set_span(3);
    row2.push(span3_left);
    let mut span2_right = Cell::new("span 2 columns", Alignment::Left);
    span2_right.set_span(2);
    row2.push(span2_right);
    table.add_row(row2);

    // Row: span 2 columns + span 3 columns
    let mut row3 = Row::new();
    let mut span2_left = Cell::new("span 2 columns", Alignment::Left);
    span2_left.set_span(2);
    row3.push(span2_left);
    let mut span3_right = Cell::new("span 3 columns", Alignment::Left);
    span3_right.set_span(3);
    row3.push(span3_right);
    table.add_row(row3);

    // Row: 1 column + span 4 columns
    let mut row4 = Row::new();
    row4.push(Cell::new("just 1 column", Alignment::Left));
    let mut span4_right = Cell::new("span 4 columns", Alignment::Left);
    span4_right.set_span(4);
    row4.push(span4_right);
    table.add_row(row4);

    // Row: all 5 individual columns
    table.add_row([
        "just 1 column",
        "just 1 column",
        "just 1 column",
        "just 1 column",
        "just 1 column",
    ]);

    table.print();
}

fn demo_invoice() {
    // Invoice style colspan example
    println!("\n=== Invoice Style with Colspan ===");
    let mut invoice = Table::new();
    invoice.set_style(TableStyle::Modern);

    // Invoice header spanning all columns
    let mut inv_header = Row::new();
    let mut inv_title = Cell::new("INVOICE #2024-001", Alignment::Center);
    inv_title.set_span(4);
    inv_header.push(inv_title);
    invoice.set_headers(inv_header);

    // Column headers
    invoice.add_row(Row::with_alignment(
        ["Item", "Qty", "Price", "Total"],
        Alignment::Center,
    ));

    // Line items
    invoice.add_row(["Widget A", "5", "$10", "$50"]);
    invoice.add_row(["Widget B", "3", "$15", "$45"]);
    invoice.add_row(["Service", "1", "$25", "$25"]);

    // Subtotal row
    let mut subtotal = Row::new();
    let mut subtotal_label = Cell::new("Subtotal:", Alignment::Right);
    subtotal_label.set_span(3);
    subtotal.push(subtotal_label);
    subtotal.push(Cell::new("$120", Alignment::Right));
    invoice.add_row(subtotal);

    // Tax row
    let mut tax = Row::new();
    let mut tax_label = Cell::new("Tax (10%):", Alignment::Right);
    tax_label.set_span(3);
    tax.push(tax_label);
    tax.push(Cell::new("$12", Alignment::Right));
    invoice.add_row(tax);

    // Grand total row
    let mut grand_total = Row::new();
    let mut total_label = Cell::new("TOTAL:", Alignment::Right);
    total_label.set_span(3);
    grand_total.push(total_label);
    grand_total.push(Cell::new("$132", Alignment::Right));
    invoice.add_row(grand_total);

    invoice.print();
}

pub fn add_row<R: Into<Row>>(&mut self, row: R)

Examples found in repository

examples/table.rs (line 19)

fn demo_styles() {
    // Basic table with Modern style
    println!("=== Modern Style ===");
    let mut table = Table::new();
    table.set_style(TableStyle::Modern);
    table.set_headers(["Name", "Age", "City"]);
    table.add_row(["Kelana", "30", "Berlin"]);
    table.add_row(["Kata", "25", "Yogyakarta"]);
    table.add_row(["Cherry Blossom", "35", "Bikini Bottom"]);
    table.print();

    // Classic style
    println!("\n=== Classic Style ===");
    table.set_style(TableStyle::Classic);
    table.print();

    // Minimal style
    println!("\n=== Minimal Style ===");
    table.set_style(TableStyle::Minimal);
    table.print();

    // Compact style
    println!("\n=== Compact Style ===");
    table.set_style(TableStyle::Compact);
    table.print();

    // Markdown style
    println!("\n=== Markdown Style ===");
    table.set_style(TableStyle::Markdown);
    table.print();
}

fn demo_builder() {
    // Using TableBuilder
    println!("\n=== TableBuilder with Constraints ===");
    TableBuilder::new()
        .style(TableStyle::Modern)
        .header(["ID", "Name", "Score"])
        .constrain(0, WidthConstraint::Fixed(5))
        .constrain(1, WidthConstraint::Min(15))
        .align(2, Alignment::Right)
        .rows([
            ["1", "Kelana", "95.5"],
            ["2", "Kata", "87.2"],
            ["3", "Cherry Blossom", "92.0"],
        ])
        .print();
}

fn demo_colspan() {
    // Colspan example
    println!("\n=== Colspan Example ===");
    let mut table = Table::new();
    table.set_style(TableStyle::Modern);

    // Header row spanning all 5 columns
    let mut header = Row::new();
    let mut title_cell = Cell::new("span all 5 columns", Alignment::Left);
    title_cell.set_span(5);
    header.push(title_cell);
    table.set_headers(header);

    // Row: span 4 columns + 1 column
    let mut row1 = Row::new();
    let mut span4 = Cell::new("span 4 columns", Alignment::Left);
    span4.set_span(4);
    row1.push(span4);
    row1.push(Cell::new("just 1 column", Alignment::Left));
    table.add_row(row1);

    // Row: span 3 columns + span 2 columns
    let mut row2 = Row::new();
    let mut span3_left = Cell::new("span 3 columns", Alignment::Left);
    span3_left.set_span(3);
    row2.push(span3_left);
    let mut span2_right = Cell::new("span 2 columns", Alignment::Left);
    span2_right.set_span(2);
    row2.push(span2_right);
    table.add_row(row2);

    // Row: span 2 columns + span 3 columns
    let mut row3 = Row::new();
    let mut span2_left = Cell::new("span 2 columns", Alignment::Left);
    span2_left.set_span(2);
    row3.push(span2_left);
    let mut span3_right = Cell::new("span 3 columns", Alignment::Left);
    span3_right.set_span(3);
    row3.push(span3_right);
    table.add_row(row3);

    // Row: 1 column + span 4 columns
    let mut row4 = Row::new();
    row4.push(Cell::new("just 1 column", Alignment::Left));
    let mut span4_right = Cell::new("span 4 columns", Alignment::Left);
    span4_right.set_span(4);
    row4.push(span4_right);
    table.add_row(row4);

    // Row: all 5 individual columns
    table.add_row([
        "just 1 column",
        "just 1 column",
        "just 1 column",
        "just 1 column",
        "just 1 column",
    ]);

    table.print();
}

fn demo_invoice() {
    // Invoice style colspan example
    println!("\n=== Invoice Style with Colspan ===");
    let mut invoice = Table::new();
    invoice.set_style(TableStyle::Modern);

    // Invoice header spanning all columns
    let mut inv_header = Row::new();
    let mut inv_title = Cell::new("INVOICE #2024-001", Alignment::Center);
    inv_title.set_span(4);
    inv_header.push(inv_title);
    invoice.set_headers(inv_header);

    // Column headers
    invoice.add_row(Row::with_alignment(
        ["Item", "Qty", "Price", "Total"],
        Alignment::Center,
    ));

    // Line items
    invoice.add_row(["Widget A", "5", "$10", "$50"]);
    invoice.add_row(["Widget B", "3", "$15", "$45"]);
    invoice.add_row(["Service", "1", "$25", "$25"]);

    // Subtotal row
    let mut subtotal = Row::new();
    let mut subtotal_label = Cell::new("Subtotal:", Alignment::Right);
    subtotal_label.set_span(3);
    subtotal.push(subtotal_label);
    subtotal.push(Cell::new("$120", Alignment::Right));
    invoice.add_row(subtotal);

    // Tax row
    let mut tax = Row::new();
    let mut tax_label = Cell::new("Tax (10%):", Alignment::Right);
    tax_label.set_span(3);
    tax.push(tax_label);
    tax.push(Cell::new("$12", Alignment::Right));
    invoice.add_row(tax);

    // Grand total row
    let mut grand_total = Row::new();
    let mut total_label = Cell::new("TOTAL:", Alignment::Right);
    total_label.set_span(3);
    grand_total.push(total_label);
    grand_total.push(Cell::new("$132", Alignment::Right));
    invoice.add_row(grand_total);

    invoice.print();
}

pub fn insert_row<R: Into<Row>>(&mut self, index: usize, row: R)

pub fn remove_row(&mut self, index: usize) -> Option<Row>

pub fn sort(&mut self, column: usize)

Sorts the rows by the content of the specified column in ascending order. Uses lexicographic (string) comparison.

pub fn sort_desc(&mut self, column: usize)

Sorts the rows by the content of the specified column in descending order. Uses lexicographic (string) comparison.

pub fn sort_num(&mut self, column: usize)

Sorts the rows by the specified column, treating cell content as numbers. Non-numeric values are treated as 0.0.

This method pre-parses numeric values before sorting for better performance on large tables.

pub fn sort_num_desc(&mut self, column: usize)

Sorts the rows by the specified column in descending order, treating content as numbers. Non-numeric values are treated as 0.0.

This method pre-parses numeric values before sorting for better performance on large tables.

pub fn sort_by<F>(&mut self, compare: F)

where F: FnMut(&Row, &Row) -> Ordering,

Sorts the rows using a custom comparison function.

pub fn filter<F>(&mut self, predicate: F)

where F: FnMut(&Row) -> bool,

Filters rows in place, keeping only those for which the predicate returns true. Headers are not affected by filtering.

pub fn filter_eq(&mut self, column: usize, value: &str)

Filters rows by the content of a specific column. Keeps rows where the column content equals the given value.

pub fn filter_col<F>(&mut self, column: usize, predicate: F)

where F: Fn(&str) -> bool,

Filters rows by the content of a specific column using a predicate. Keeps rows where the predicate returns true for the column content.

pub fn filter_has(&mut self, column: usize, substring: &str)

Filters rows where the specified column content contains the given substring.

pub fn filtered<F>(&self, predicate: F) -> Self

where F: FnMut(&Row) -> bool,

Returns a new table containing only rows that match the predicate. The original table is not modified. Headers, style, and other settings are copied.

pub fn add_column(&mut self, values: &[&str], alignment: Alignment)

Adds a new column to the table with the given values. The first value becomes the header (if headers exist), and the rest become row values. If there are more rows than values, empty cells are added. If there are more values than rows, extra values are ignored.

pub fn insert_column( &mut self, index: usize, values: &[&str], alignment: Alignment, )

Inserts a new column at the specified index. The first value becomes the header (if headers exist), and the rest become row values.

pub fn remove_column(&mut self, index: usize) -> bool

Removes a column at the specified index from all rows and headers. Returns true if the column was removed, false if the index was out of bounds.

pub fn cols(&self) -> usize

Returns the number of columns in the table. Based on the maximum cell count across headers and all rows.

pub fn set_style(&mut self, style: TableStyle)

Examples found in repository

examples/table.rs (line 17)

fn demo_styles() {
    // Basic table with Modern style
    println!("=== Modern Style ===");
    let mut table = Table::new();
    table.set_style(TableStyle::Modern);
    table.set_headers(["Name", "Age", "City"]);
    table.add_row(["Kelana", "30", "Berlin"]);
    table.add_row(["Kata", "25", "Yogyakarta"]);
    table.add_row(["Cherry Blossom", "35", "Bikini Bottom"]);
    table.print();

    // Classic style
    println!("\n=== Classic Style ===");
    table.set_style(TableStyle::Classic);
    table.print();

    // Minimal style
    println!("\n=== Minimal Style ===");
    table.set_style(TableStyle::Minimal);
    table.print();

    // Compact style
    println!("\n=== Compact Style ===");
    table.set_style(TableStyle::Compact);
    table.print();

    // Markdown style
    println!("\n=== Markdown Style ===");
    table.set_style(TableStyle::Markdown);
    table.print();
}

fn demo_builder() {
    // Using TableBuilder
    println!("\n=== TableBuilder with Constraints ===");
    TableBuilder::new()
        .style(TableStyle::Modern)
        .header(["ID", "Name", "Score"])
        .constrain(0, WidthConstraint::Fixed(5))
        .constrain(1, WidthConstraint::Min(15))
        .align(2, Alignment::Right)
        .rows([
            ["1", "Kelana", "95.5"],
            ["2", "Kata", "87.2"],
            ["3", "Cherry Blossom", "92.0"],
        ])
        .print();
}

fn demo_colspan() {
    // Colspan example
    println!("\n=== Colspan Example ===");
    let mut table = Table::new();
    table.set_style(TableStyle::Modern);

    // Header row spanning all 5 columns
    let mut header = Row::new();
    let mut title_cell = Cell::new("span all 5 columns", Alignment::Left);
    title_cell.set_span(5);
    header.push(title_cell);
    table.set_headers(header);

    // Row: span 4 columns + 1 column
    let mut row1 = Row::new();
    let mut span4 = Cell::new("span 4 columns", Alignment::Left);
    span4.set_span(4);
    row1.push(span4);
    row1.push(Cell::new("just 1 column", Alignment::Left));
    table.add_row(row1);

    // Row: span 3 columns + span 2 columns
    let mut row2 = Row::new();
    let mut span3_left = Cell::new("span 3 columns", Alignment::Left);
    span3_left.set_span(3);
    row2.push(span3_left);
    let mut span2_right = Cell::new("span 2 columns", Alignment::Left);
    span2_right.set_span(2);
    row2.push(span2_right);
    table.add_row(row2);

    // Row: span 2 columns + span 3 columns
    let mut row3 = Row::new();
    let mut span2_left = Cell::new("span 2 columns", Alignment::Left);
    span2_left.set_span(2);
    row3.push(span2_left);
    let mut span3_right = Cell::new("span 3 columns", Alignment::Left);
    span3_right.set_span(3);
    row3.push(span3_right);
    table.add_row(row3);

    // Row: 1 column + span 4 columns
    let mut row4 = Row::new();
    row4.push(Cell::new("just 1 column", Alignment::Left));
    let mut span4_right = Cell::new("span 4 columns", Alignment::Left);
    span4_right.set_span(4);
    row4.push(span4_right);
    table.add_row(row4);

    // Row: all 5 individual columns
    table.add_row([
        "just 1 column",
        "just 1 column",
        "just 1 column",
        "just 1 column",
        "just 1 column",
    ]);

    table.print();
}

fn demo_invoice() {
    // Invoice style colspan example
    println!("\n=== Invoice Style with Colspan ===");
    let mut invoice = Table::new();
    invoice.set_style(TableStyle::Modern);

    // Invoice header spanning all columns
    let mut inv_header = Row::new();
    let mut inv_title = Cell::new("INVOICE #2024-001", Alignment::Center);
    inv_title.set_span(4);
    inv_header.push(inv_title);
    invoice.set_headers(inv_header);

    // Column headers
    invoice.add_row(Row::with_alignment(
        ["Item", "Qty", "Price", "Total"],
        Alignment::Center,
    ));

    // Line items
    invoice.add_row(["Widget A", "5", "$10", "$50"]);
    invoice.add_row(["Widget B", "3", "$15", "$45"]);
    invoice.add_row(["Service", "1", "$25", "$25"]);

    // Subtotal row
    let mut subtotal = Row::new();
    let mut subtotal_label = Cell::new("Subtotal:", Alignment::Right);
    subtotal_label.set_span(3);
    subtotal.push(subtotal_label);
    subtotal.push(Cell::new("$120", Alignment::Right));
    invoice.add_row(subtotal);

    // Tax row
    let mut tax = Row::new();
    let mut tax_label = Cell::new("Tax (10%):", Alignment::Right);
    tax_label.set_span(3);
    tax.push(tax_label);
    tax.push(Cell::new("$12", Alignment::Right));
    invoice.add_row(tax);

    // Grand total row
    let mut grand_total = Row::new();
    let mut total_label = Cell::new("TOTAL:", Alignment::Right);
    total_label.set_span(3);
    grand_total.push(total_label);
    grand_total.push(Cell::new("$132", Alignment::Right));
    invoice.add_row(grand_total);

    invoice.print();
}

pub fn set_padding(&mut self, padding: Padding)

pub fn spacing(&mut self, spacing: usize)

pub fn align(&mut self, column: usize, alignment: Alignment)

pub fn valign(&mut self, alignment: VerticalAlignment)

pub fn constrain(&mut self, constraint: WidthConstraint)

pub fn set_constraint(&mut self, column: usize, constraint: WidthConstraint)

pub fn constraints(&self) -> &[WidthConstraint]

pub fn rows(&self) -> &[Row]

pub fn headers(&self) -> Option<&Row>

pub fn style(&self) -> TableStyle

pub fn padding(&self) -> Padding

pub fn get_spacing(&self) -> usize

pub fn get_align(&self, column: usize) -> Option<Alignment>

pub fn get_valign(&self) -> VerticalAlignment

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn row<R: Into<Row>>(self, cells: R) -> Self

pub fn header<R: Into<Row>>(self, headers: R) -> Self

pub fn truncate(self, limit: usize) -> Self

pub fn print(&self)

Examples found in repository

examples/table.rs (line 22)

fn demo_styles() {
    // Basic table with Modern style
    println!("=== Modern Style ===");
    let mut table = Table::new();
    table.set_style(TableStyle::Modern);
    table.set_headers(["Name", "Age", "City"]);
    table.add_row(["Kelana", "30", "Berlin"]);
    table.add_row(["Kata", "25", "Yogyakarta"]);
    table.add_row(["Cherry Blossom", "35", "Bikini Bottom"]);
    table.print();

    // Classic style
    println!("\n=== Classic Style ===");
    table.set_style(TableStyle::Classic);
    table.print();

    // Minimal style
    println!("\n=== Minimal Style ===");
    table.set_style(TableStyle::Minimal);
    table.print();

    // Compact style
    println!("\n=== Compact Style ===");
    table.set_style(TableStyle::Compact);
    table.print();

    // Markdown style
    println!("\n=== Markdown Style ===");
    table.set_style(TableStyle::Markdown);
    table.print();
}

fn demo_builder() {
    // Using TableBuilder
    println!("\n=== TableBuilder with Constraints ===");
    TableBuilder::new()
        .style(TableStyle::Modern)
        .header(["ID", "Name", "Score"])
        .constrain(0, WidthConstraint::Fixed(5))
        .constrain(1, WidthConstraint::Min(15))
        .align(2, Alignment::Right)
        .rows([
            ["1", "Kelana", "95.5"],
            ["2", "Kata", "87.2"],
            ["3", "Cherry Blossom", "92.0"],
        ])
        .print();
}

fn demo_colspan() {
    // Colspan example
    println!("\n=== Colspan Example ===");
    let mut table = Table::new();
    table.set_style(TableStyle::Modern);

    // Header row spanning all 5 columns
    let mut header = Row::new();
    let mut title_cell = Cell::new("span all 5 columns", Alignment::Left);
    title_cell.set_span(5);
    header.push(title_cell);
    table.set_headers(header);

    // Row: span 4 columns + 1 column
    let mut row1 = Row::new();
    let mut span4 = Cell::new("span 4 columns", Alignment::Left);
    span4.set_span(4);
    row1.push(span4);
    row1.push(Cell::new("just 1 column", Alignment::Left));
    table.add_row(row1);

    // Row: span 3 columns + span 2 columns
    let mut row2 = Row::new();
    let mut span3_left = Cell::new("span 3 columns", Alignment::Left);
    span3_left.set_span(3);
    row2.push(span3_left);
    let mut span2_right = Cell::new("span 2 columns", Alignment::Left);
    span2_right.set_span(2);
    row2.push(span2_right);
    table.add_row(row2);

    // Row: span 2 columns + span 3 columns
    let mut row3 = Row::new();
    let mut span2_left = Cell::new("span 2 columns", Alignment::Left);
    span2_left.set_span(2);
    row3.push(span2_left);
    let mut span3_right = Cell::new("span 3 columns", Alignment::Left);
    span3_right.set_span(3);
    row3.push(span3_right);
    table.add_row(row3);

    // Row: 1 column + span 4 columns
    let mut row4 = Row::new();
    row4.push(Cell::new("just 1 column", Alignment::Left));
    let mut span4_right = Cell::new("span 4 columns", Alignment::Left);
    span4_right.set_span(4);
    row4.push(span4_right);
    table.add_row(row4);

    // Row: all 5 individual columns
    table.add_row([
        "just 1 column",
        "just 1 column",
        "just 1 column",
        "just 1 column",
        "just 1 column",
    ]);

    table.print();
}

fn demo_invoice() {
    // Invoice style colspan example
    println!("\n=== Invoice Style with Colspan ===");
    let mut invoice = Table::new();
    invoice.set_style(TableStyle::Modern);

    // Invoice header spanning all columns
    let mut inv_header = Row::new();
    let mut inv_title = Cell::new("INVOICE #2024-001", Alignment::Center);
    inv_title.set_span(4);
    inv_header.push(inv_title);
    invoice.set_headers(inv_header);

    // Column headers
    invoice.add_row(Row::with_alignment(
        ["Item", "Qty", "Price", "Total"],
        Alignment::Center,
    ));

    // Line items
    invoice.add_row(["Widget A", "5", "$10", "$50"]);
    invoice.add_row(["Widget B", "3", "$15", "$45"]);
    invoice.add_row(["Service", "1", "$25", "$25"]);

    // Subtotal row
    let mut subtotal = Row::new();
    let mut subtotal_label = Cell::new("Subtotal:", Alignment::Right);
    subtotal_label.set_span(3);
    subtotal.push(subtotal_label);
    subtotal.push(Cell::new("$120", Alignment::Right));
    invoice.add_row(subtotal);

    // Tax row
    let mut tax = Row::new();
    let mut tax_label = Cell::new("Tax (10%):", Alignment::Right);
    tax_label.set_span(3);
    tax.push(tax_label);
    tax.push(Cell::new("$12", Alignment::Right));
    invoice.add_row(tax);

    // Grand total row
    let mut grand_total = Row::new();
    let mut total_label = Cell::new("TOTAL:", Alignment::Right);
    total_label.set_span(3);
    grand_total.push(total_label);
    grand_total.push(Cell::new("$132", Alignment::Right));
    invoice.add_row(grand_total);

    invoice.print();
}

pub fn render_into(&self, buf: &mut Vec<u8>) -> Result

Renders the table into a provided byte buffer, reusing the allocation.

This method allows for zero-allocation rendering when the buffer is reused across multiple renders, making it ideal for repeated rendering scenarios like pagination or filtering UI.

Arguments

• buf - A buffer to render into. Will be cleared and reused.

Returns

• Ok(()) if rendering succeeded

Errors

This function currently never returns an error, but returns Result for future compatibility with potential I/O operations.

Examples

let mut buffer = Vec::with_capacity(4096);
for item in items {
    buffer.clear();
    table.render_into(&mut buffer)?;
    stdout.write_all(&buffer)?;
}

pub fn format_cell(content: &str, width: usize, alignment: Alignment) -> String

Formats a cell’s content with the given width and alignment.

This is a lower-level function that can be useful for custom formatting needs.

Arguments

• content - The cell content to format
• width - The target width for the formatted output
• alignment - The alignment to use

Returns

The formatted string with appropriate padding

Examples

let formatted = Table::format_cell("test", 10, Alignment::Left);
assert_eq!(formatted, "test      ");

pub fn render(&self) -> String

pub fn render_cached(&self) -> String

Renders the table using cached column widths if available.

This method provides improved performance for repeated renders of the same table. The first call calculates and caches column widths. Subsequent calls reuse the cache until the table is modified.

Returns

The rendered table as a String

Examples

let table = Table::new().header(&["A", "B"]).row(&["1", "2"]);
let _first = table.render_cached(); // Calculates and caches widths
let _second = table.render_cached(); // Uses cached widths (faster)

pub fn recalculate_widths(&mut self)

Forces recalculation of column widths on the next render.

This method is primarily useful when the table has been modified externally or when you want to ensure fresh calculations.

Examples

let mut table = Table::new().header(&["A", "B"]).row(&["1", "2"]);
table.recalculate_widths();

Trait Implementations

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.