Struct NuTable 

pub struct NuTable { /* private fields */ }

NuTable is a table rendering implementation.

Implementations

impl NuTable

pub fn new(count_rows: usize, count_cols: usize) -> Self

Creates an empty NuTable instance.

Examples found in repository

examples/table_demo.rs (line 24)

fn main() {
    let args: Vec<_> = std::env::args().collect();
    let mut width = 0;

    if args.len() > 1 {
        width = args[1].parse::<usize>().expect("Need a width in columns");
    }

    if width < 4 {
        println!("Width must be greater than or equal to 4, setting width to 80");
        width = 80;
    }

    let (table_headers, row_data) = make_table_data();

    let headers = to_cell_info_vec(&table_headers);
    let rows = to_cell_info_vec(&row_data);

    let mut table = NuTable::new(4, 3);
    table.set_row(0, headers);

    for i in 0..3 {
        table.set_row(i + 1, rows.clone());
    }

    table.set_data_style(TextStyle::basic_left());
    table.set_header_style(TextStyle::basic_center().style(Style::new().on(Color::Blue)));
    table.set_theme(TableTheme::rounded());
    table.set_structure(false, true, false);

    let output_table = table
        .draw(width)
        .unwrap_or_else(|| format!("Couldn't fit table into {width} columns!"));

    println!("{output_table}")
}

pub fn count_rows(&self) -> usize

Return amount of rows.

pub fn count_columns(&self) -> usize

Return amount of columns.

pub fn create(text: String) -> NuRecordsValue

pub fn insert_value(&mut self, pos: (usize, usize), value: NuRecordsValue)

pub fn insert(&mut self, pos: (usize, usize), text: String)

pub fn set_row(&mut self, index: usize, row: Vec<NuRecordsValue>)

Examples found in repository

examples/table_demo.rs (line 25)

fn main() {
    let args: Vec<_> = std::env::args().collect();
    let mut width = 0;

    if args.len() > 1 {
        width = args[1].parse::<usize>().expect("Need a width in columns");
    }

    if width < 4 {
        println!("Width must be greater than or equal to 4, setting width to 80");
        width = 80;
    }

    let (table_headers, row_data) = make_table_data();

    let headers = to_cell_info_vec(&table_headers);
    let rows = to_cell_info_vec(&row_data);

    let mut table = NuTable::new(4, 3);
    table.set_row(0, headers);

    for i in 0..3 {
        table.set_row(i + 1, rows.clone());
    }

    table.set_data_style(TextStyle::basic_left());
    table.set_header_style(TextStyle::basic_center().style(Style::new().on(Color::Blue)));
    table.set_theme(TableTheme::rounded());
    table.set_structure(false, true, false);

    let output_table = table
        .draw(width)
        .unwrap_or_else(|| format!("Couldn't fit table into {width} columns!"));

    println!("{output_table}")
}

pub fn pop_column(&mut self, count: usize)

pub fn push_column(&mut self, text: String)

pub fn insert_style(&mut self, pos: (usize, usize), style: TextStyle)

pub fn set_header_style(&mut self, style: TextStyle)

Examples found in repository

examples/table_demo.rs (line 32)

fn main() {
    let args: Vec<_> = std::env::args().collect();
    let mut width = 0;

    if args.len() > 1 {
        width = args[1].parse::<usize>().expect("Need a width in columns");
    }

    if width < 4 {
        println!("Width must be greater than or equal to 4, setting width to 80");
        width = 80;
    }

    let (table_headers, row_data) = make_table_data();

    let headers = to_cell_info_vec(&table_headers);
    let rows = to_cell_info_vec(&row_data);

    let mut table = NuTable::new(4, 3);
    table.set_row(0, headers);

    for i in 0..3 {
        table.set_row(i + 1, rows.clone());
    }

    table.set_data_style(TextStyle::basic_left());
    table.set_header_style(TextStyle::basic_center().style(Style::new().on(Color::Blue)));
    table.set_theme(TableTheme::rounded());
    table.set_structure(false, true, false);

    let output_table = table
        .draw(width)
        .unwrap_or_else(|| format!("Couldn't fit table into {width} columns!"));

    println!("{output_table}")
}

pub fn set_index_style(&mut self, style: TextStyle)

pub fn set_data_style(&mut self, style: TextStyle)

Examples found in repository

examples/table_demo.rs (line 31)

fn main() {
    let args: Vec<_> = std::env::args().collect();
    let mut width = 0;

    if args.len() > 1 {
        width = args[1].parse::<usize>().expect("Need a width in columns");
    }

    if width < 4 {
        println!("Width must be greater than or equal to 4, setting width to 80");
        width = 80;
    }

    let (table_headers, row_data) = make_table_data();

    let headers = to_cell_info_vec(&table_headers);
    let rows = to_cell_info_vec(&row_data);

    let mut table = NuTable::new(4, 3);
    table.set_row(0, headers);

    for i in 0..3 {
        table.set_row(i + 1, rows.clone());
    }

    table.set_data_style(TextStyle::basic_left());
    table.set_header_style(TextStyle::basic_center().style(Style::new().on(Color::Blue)));
    table.set_theme(TableTheme::rounded());
    table.set_structure(false, true, false);

    let output_table = table
        .draw(width)
        .unwrap_or_else(|| format!("Couldn't fit table into {width} columns!"));

    println!("{output_table}")
}

pub fn set_indent(&mut self, indent: TableIndent)

pub fn set_theme(&mut self, theme: TableTheme)

Examples found in repository

examples/table_demo.rs (line 33)

fn main() {
    let args: Vec<_> = std::env::args().collect();
    let mut width = 0;

    if args.len() > 1 {
        width = args[1].parse::<usize>().expect("Need a width in columns");
    }

    if width < 4 {
        println!("Width must be greater than or equal to 4, setting width to 80");
        width = 80;
    }

    let (table_headers, row_data) = make_table_data();

    let headers = to_cell_info_vec(&table_headers);
    let rows = to_cell_info_vec(&row_data);

    let mut table = NuTable::new(4, 3);
    table.set_row(0, headers);

    for i in 0..3 {
        table.set_row(i + 1, rows.clone());
    }

    table.set_data_style(TextStyle::basic_left());
    table.set_header_style(TextStyle::basic_center().style(Style::new().on(Color::Blue)));
    table.set_theme(TableTheme::rounded());
    table.set_structure(false, true, false);

    let output_table = table
        .draw(width)
        .unwrap_or_else(|| format!("Couldn't fit table into {width} columns!"));

    println!("{output_table}")
}

pub fn set_structure(&mut self, index: bool, header: bool, footer: bool)

Examples found in repository

examples/table_demo.rs (line 34)

fn main() {
    let args: Vec<_> = std::env::args().collect();
    let mut width = 0;

    if args.len() > 1 {
        width = args[1].parse::<usize>().expect("Need a width in columns");
    }

    if width < 4 {
        println!("Width must be greater than or equal to 4, setting width to 80");
        width = 80;
    }

    let (table_headers, row_data) = make_table_data();

    let headers = to_cell_info_vec(&table_headers);
    let rows = to_cell_info_vec(&row_data);

    let mut table = NuTable::new(4, 3);
    table.set_row(0, headers);

    for i in 0..3 {
        table.set_row(i + 1, rows.clone());
    }

    table.set_data_style(TextStyle::basic_left());
    table.set_header_style(TextStyle::basic_center().style(Style::new().on(Color::Blue)));
    table.set_theme(TableTheme::rounded());
    table.set_structure(false, true, false);

    let output_table = table
        .draw(width)
        .unwrap_or_else(|| format!("Couldn't fit table into {width} columns!"));

    println!("{output_table}")
}

pub fn set_border_header(&mut self, on: bool)

pub fn set_trim(&mut self, strategy: TrimStrategy)

pub fn set_strategy(&mut self, expand: bool)

pub fn set_border_color(&mut self, color: Style)

pub fn clear_border_color(&mut self)

pub fn get_records_mut(&mut self) -> &mut [Vec<NuRecordsValue>]

pub fn clear_all_colors(&mut self)

pub fn draw(self, termwidth: usize) -> Option<String>

Converts a table to a String.

It returns None in case where table cannot be fit to a terminal width.

Examples found in repository

examples/table_demo.rs (line 37)

fn main() {
    let args: Vec<_> = std::env::args().collect();
    let mut width = 0;

    if args.len() > 1 {
        width = args[1].parse::<usize>().expect("Need a width in columns");
    }

    if width < 4 {
        println!("Width must be greater than or equal to 4, setting width to 80");
        width = 80;
    }

    let (table_headers, row_data) = make_table_data();

    let headers = to_cell_info_vec(&table_headers);
    let rows = to_cell_info_vec(&row_data);

    let mut table = NuTable::new(4, 3);
    table.set_row(0, headers);

    for i in 0..3 {
        table.set_row(i + 1, rows.clone());
    }

    table.set_data_style(TextStyle::basic_left());
    table.set_header_style(TextStyle::basic_center().style(Style::new().on(Color::Blue)));
    table.set_theme(TableTheme::rounded());
    table.set_structure(false, true, false);

    let output_table = table
        .draw(width)
        .unwrap_or_else(|| format!("Couldn't fit table into {width} columns!"));

    println!("{output_table}")
}

pub fn draw_unchecked(self, termwidth: usize) -> Option<String>

Converts a table to a String.

It returns None in case where table cannot be fit to a terminal width.

pub fn total_width(&self) -> usize

Return a total table width.

Trait Implementations

impl Clone for NuTable

fn clone(&self) -> NuTable

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NuTable

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

Formats the value using the given formatter.

impl From<Vec<Vec<Text<String>>>> for NuTable

fn from(value: Vec<Vec<Text<String>>>) -> Self

Converts to this type from the input type.