Struct TabulateOptions 

pub struct TabulateOptions {

    pub headers: Headers,
    pub table_format: TableFormatChoice,
    pub float_format: FormatSpec,
    pub int_format: FormatSpec,
    pub num_align: Option<Alignment>,
    pub str_align: Option<Alignment>,
    pub missing_values: MissingValues,
    pub show_index: ShowIndex,
    pub disable_numparse: bool,
    pub disable_numparse_columns: Option<Vec<usize>>,
    pub preserve_whitespace: bool,
    pub enable_widechars: bool,
    pub max_col_widths: Option<Vec<Option<usize>>>,
    pub max_header_col_widths: Option<Vec<Option<usize>>>,
    pub col_global_align: Option<Alignment>,
    pub col_align: Vec<Option<Alignment>>,
    pub headers_global_align: Option<Alignment>,
    pub headers_align: Vec<Option<HeaderAlignment>>,
    pub row_align: Vec<Option<RowAlignment>>,
    pub row_global_align: Option<RowAlignment>,
    pub break_long_words: bool,
    pub break_on_hyphens: bool,
}

Builder-style configuration for tabulate.

Fields

headers: Headers

Header configuration.

table_format: TableFormatChoice

Table format selection (either a named format or a custom specification).

float_format: FormatSpec

Floating point number formatting.

int_format: FormatSpec

Integer number formatting.

num_align: Option<Alignment>

Alignment for numeric columns.

str_align: Option<Alignment>

Alignment for string columns.

missing_values: MissingValues

Replacement value for None/missing data.

show_index: ShowIndex

Index column behaviour.

disable_numparse: bool

Disable automatic detection of numeric values.

disable_numparse_columns: Option<Vec<usize>>

Disable numeric parsing for specific columns (0-indexed).

preserve_whitespace: bool

Preserve the original whitespace provided in the data.

enable_widechars: bool

Treat East Asian wide characters using double-width measurements.

max_col_widths: Option<Vec<Option<usize>>>

Maximum column widths (if any).

max_header_col_widths: Option<Vec<Option<usize>>>

Maximum header column widths (if any).

col_global_align: Option<Alignment>

Alignment override applied to every column.

col_align: Vec<Option<Alignment>>

Alignment overrides per column.

headers_global_align: Option<Alignment>

Alignment override for header row.

headers_align: Vec<Option<HeaderAlignment>>

Alignment overrides per-header cell.

row_align: Vec<Option<RowAlignment>>

Alignment override applied to rows.

row_global_align: Option<RowAlignment>

Alignment override applied to all rows.

break_long_words: bool

Control how long words are wrapped.

break_on_hyphens: bool

Control whether words can be wrapped on hyphens.

Implementations

impl TabulateOptions

pub fn new() -> Self

Construct a new options builder with default configuration.

Examples found in repository

examples/basic.rs (line 14)

fn main() {
    let planets = vec![
        vec!["Planet", "Radius (km)", "Mass (10^24 kg)"],
        vec!["Mercury", "2440", "0.330"],
        vec!["Venus", "6052", "4.87"],
        vec!["Earth", "6371", "5.97"],
        vec!["Mars", "3390", "0.642"],
    ];

    let table = tabulate(
        planets,
        TabulateOptions::new()
            .headers(Headers::FirstRow)
            .table_format("grid"),
    )
    .expect("tabulation succeeds");

    println!("{table}");
}

pub fn headers(self, headers: Headers) -> Self

Set explicit headers.

Examples found in repository

examples/basic.rs (line 15)

fn main() {
    let planets = vec![
        vec!["Planet", "Radius (km)", "Mass (10^24 kg)"],
        vec!["Mercury", "2440", "0.330"],
        vec!["Venus", "6052", "4.87"],
        vec!["Earth", "6371", "5.97"],
        vec!["Mars", "3390", "0.642"],
    ];

    let table = tabulate(
        planets,
        TabulateOptions::new()
            .headers(Headers::FirstRow)
            .table_format("grid"),
    )
    .expect("tabulation succeeds");

    println!("{table}");
}

pub fn table_format<S: Into<String>>(self, format: S) -> Self

Set table format by name.

Examples found in repository

examples/basic.rs (line 16)

fn main() {
    let planets = vec![
        vec!["Planet", "Radius (km)", "Mass (10^24 kg)"],
        vec!["Mercury", "2440", "0.330"],
        vec!["Venus", "6052", "4.87"],
        vec!["Earth", "6371", "5.97"],
        vec!["Mars", "3390", "0.642"],
    ];

    let table = tabulate(
        planets,
        TabulateOptions::new()
            .headers(Headers::FirstRow)
            .table_format("grid"),
    )
    .expect("tabulation succeeds");

    println!("{table}");
}

pub fn table_format_custom(self, format: TableFormat) -> Self

Supply a custom TableFormat.

pub fn float_format(self, format: FormatSpec) -> Self

Set floating point format.

pub fn int_format(self, format: FormatSpec) -> Self

Set integer format.

pub fn num_align(self, align: Alignment) -> Self

Set numeric column alignment.

pub fn col_global_align(self, align: Alignment) -> Self

Override alignment for all columns.

pub fn str_align(self, align: Alignment) -> Self

Set string column alignment.

pub fn missing_value<S: Into<String>>(self, value: S) -> Self

Set the placeholder for missing values.

pub fn missing_values<I, S>(self, values: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

Set per-column placeholders for missing values.

pub fn disable_numparse(self, disable: bool) -> Self

Control whether tabulate should attempt to parse numeric values.

pub fn disable_numparse_columns<I>(self, columns: I) -> Self

where I: IntoIterator<Item = usize>,

Disable numeric parsing for specific columns (0-indexed).

pub fn is_numparse_disabled(&self, column: Option<usize>) -> bool

Returns true if numeric parsing is disabled for the provided column.

pub fn preserve_whitespace(self, preserve: bool) -> Self

Control whitespace preservation.

pub fn enable_widechars(self, enable: bool) -> Self

Enable width calculations that treat East Asian wide characters as double width.

pub fn show_index(self, show_index: ShowIndex) -> Self

Configure how the index column is displayed.

pub fn max_col_widths(self, widths: Vec<Option<usize>>) -> Self

Set per-column maximum widths. Use None for columns without limits.

pub fn max_col_width(self, width: usize) -> Self

Set the same maximum width for all columns.

pub fn max_header_col_widths(self, widths: Vec<Option<usize>>) -> Self

Set per-column maximum header widths. Use None for unlimited columns.

pub fn max_header_col_width(self, width: usize) -> Self

Set the same maximum width for all header columns.

pub fn headers_mapping<I, K, V>(self, mapping: I) -> Self

where I: IntoIterator<Item = (K, V)>, K: Into<String>, V: Into<String>,

Provide a mapping from column keys to display headers.

pub fn col_alignments<I>(self, aligns: I) -> Self

where I: IntoIterator<Item = Option<Alignment>>,

Provide per-column alignment overrides.

pub fn headers_global_align(self, align: Alignment) -> Self

Override alignment for all headers.

pub fn headers_alignments<I>(self, aligns: I) -> Self

where I: IntoIterator<Item = Option<HeaderAlignment>>,

Provide per-header alignment overrides.

pub fn row_global_align(self, align: RowAlignment) -> Self

Override the default alignment for all data rows.

pub fn row_alignments<I>(self, aligns: I) -> Self

where I: IntoIterator<Item = Option<RowAlignment>>,

Provide per-row alignment overrides.

Trait Implementations

impl Clone for TabulateOptions

fn clone(&self) -> TabulateOptions

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TabulateOptions

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

Formats the value using the given formatter.

impl Default for TabulateOptions

fn default() -> Self

Returns the “default value” for a type.