Add a new row to the table. ``` use comfy_table::{Row, Table}; let mut table = Table::new(); table.add_row(vec!["One", "Two"]); ```

Set the header row of the table. This is usually the title of each column.\ There'll be no header unless you explicitly set it with this function. ``

Specify how Comfy Table should arrange the content in your table. ``` use comfy_table::{ContentArrangement, Table}; let mut table = Table::new(); ta

Enforce a max width that should be used in combination with [dynamic content arrangement](ContentArrangement::Dynamic).\ This is usually not necessary

Load a [TableStyle] for this table, replacing the current style. \ Preset styles can be found in the [presets](crate::style::presets) module. You can

Convenience method to set a [ColumnConstraint] for all columns at once. Constraints are used to influence the way the columns will be arranged. Check

Get a mutable reference to a specific column.

Constraints allow to influence the auto-adjustment behavior of columns.\ This can be useful to counter undesired auto-adjustment of content in tables.

Truncate content of cells which occupies more than X lines of space. At least one line of content is always shown, hence a value of `0` is implicitly

This is an alternative to `fmt`, but rather returns an iterator to each line, rather than one String separated by newlines.

Add a new row to the table if the predicate evaluates to `true`. ``` use comfy_table::{Row, Table}; let mut table = Table::new(); table.add_row_if(|

Iterator over all columns

A little wrapper, which resolves possible upper boundary constraints to their actual value for the current table and terminal width. This returns the

Resolve an absolute value from a given boundary

The ColumnDisplayInfo works with a fixed value for content width. However, if a column is supposed to get a absolute width, we have to make sure that

Add a cell to the row. Attention: If a row has already been added to a table and you add more cells to it than there're columns currently know to the

Add multiple rows to the table. ``` use comfy_table::{Row, Table}; let mut table = Table::new(); let rows = vec![vec!["One", "Two"], vec!["Three", "

Add multiple rows to the table if the predicate evaluates to `true`. ``` use comfy_table::{Row, Table}; let mut table = Table::new(); let rows = vec

Whether this column already has a decided width.

Returns if the table is empty (contains no data rows). ``` use comfy_table::Table; let mut table = Table::new(); assert!(table.is_empty()); table.a

Returns weather the columns is hidden via [ColumnConstraint::Hidden].

Set the padding for all cells of this column. Padding is provided in the form of (left, right).\ Default is `(1, 1)`.

Autogenerate new columns, if a row is added with more cells than existing columns.

The average remaining space per undecided column. Returns 0 if no undecided columns remain.

Get a mutable iterator over all columns. ``` use comfy_table::{ColumnConstraint::*, Table, Width::*}; let mut table = Table::new(); table.add_row(&v

Return the amount of border columns, that will be visible in the final table output.

Fix `column` to `content_width` and adjust `remaining_width` and `remaining_columns` accordingly. Returns `false` when no undecided columns remain af

A little wrapper, which resolves possible lower boundary constraints to their actual value for the current table and terminal width. This returns the

Convenience helper that returns the total width of the combined padding.

Get a mutable iterator over all rows. ``` use comfy_table::Table; let mut table = Table::new(); table.add_row(&vec!["First", "Second", "Third"]); //

Top level entry point for content arrangement.

Get the amount of cells on this row.

Returns an iterator over all cells of this row

Return a vector representing the maximum amount of characters in any line of this column.\ Attention** This scans the whole current content of the ta

Get the constraint that is used for this column.

Set the style of the lines that contain the rows' content.

Calling this might be necessary if you add new cells to rows that're already added to the table. If more cells than're currently know to the table ar

Split `width` into `count` relatively equal chunks. Since we do integer division, there is most likely a little bit of non equally-divisible space. W

Set the fill character.

Fixes ansi escape codes in a split string 1. Adds reset code to the end of each substring if needed. 2. Keeps track of previous substring's escape cod

Set the style of the lines that contain the header's content.

Set the line that's drawn between the header and the first row.

Set the left border character.

Get the longest content width for all cells of this row

Set the right border character.

Set the truncation indicator for cells that are too long to be displayed. Defaults to "…". Set it to "..." for example if you want to stick to ASCII.

Split a line if it's longer than the allowed columns (width - padding). This function tries to do this in a smart way, by splitting the content with

Splits a long word at a given character width. This needs some special logic, as we have to take multi-character UTF-8 symbols into account. When simp

Determine which columns contain wide (display width 2) characters. Wide characters cannot be broken apart to fit into a column with a content width o

Try to find the best fit for a given content and table_width 1. Determine the amount of available space after applying fixed columns, padding, and bo

Set the bottom border of the table.

Each cell can have any alignment.

Generate random cell content. The `|` char, newlines and control chars are explicitly not included. Those would break the delimiter-based column chec

Check if the current line is too long and whether we should start a new one If it's too long, we add the current line to the list of lines and return

Get a mutable iterator over cells of a column, including the header cell. The header cell will be the very first cell returned. The iterator returns a

Any Column can have any constellation of ColumnConstraints

Return a copy of the content contained in this cell.

Get the current content arrangement of the table.

Return the amount of visible columns that haven't been checked yet. - `column_count` is the total amount of columns that are visible, calculated with

Return the amount of visible columns

Get the delimiter for a Cell. Priority is in decreasing order: Cell -> Column -> Table.

Step 6 - Second branch Not all columns have a determined width yet -> The content still doesn't fully fit into the given width. This function now eq

The horizontal line that separates between rows.

Step 5 Determine, whether there are any columns that are allowed to occupy more width than the current `average_space` via a [LowerBoundary] constrai

Look at given constraints of a column and check if some of them can be resolved at the very beginning. For example: - We get an absolute width. - Min

Step 2-4 This function is part of the column width calculation process. It checks if there are columns that take less space than there's currently ava

Returns the formatted content of the table. The content is organized in the following structure tc stands for table content and represents the return