struct libscols_table

struct libscols_table;

A table - The most abstract object, encapsulating lines, columns, symbols and cells

scols_copy_table ()

struct libscols_table * scols_copy_table                (struct libscols_table *tb);

Creates a new independent table copy, except struct libscols_symbols that are shared between the tables.

scols_new_table ()

struct libscols_table * scols_new_table                 (void);

scols_ref_table ()

void                scols_ref_table                     (struct libscols_table *tb);

Increases the refcount of tb.

scols_table_add_column ()

int                 scols_table_add_column              (struct libscols_table *tb,
                                                         struct libscols_column *cl);

Adds cl to tb's column list.

scols_table_add_line ()

int                 scols_table_add_line                (struct libscols_table *tb,
                                                         struct libscols_line *ln);

Note that this function calls scols_line_alloc_cells() if number of the cells in the line is too small for tb.

scols_table_colors_wanted ()

int                 scols_table_colors_wanted           (struct libscols_table *tb);

scols_table_enable_ascii ()

int                 scols_table_enable_ascii            (struct libscols_table *tb,
                                                         int enable);

The ASCII-only output is relevant for tree-like outputs. The library checks if the current environment is UTF8 compatible by default. This function overrides this check and force the library to use ASCII chars for the tree.

If a custom libcols_symbols are specified (see scols_table_set_symbols() then ASCII flag setting is ignored.

scols_table_enable_colors ()

int                 scols_table_enable_colors           (struct libscols_table *tb,
                                                         int enable);

Enable/disable colors.

scols_table_enable_export ()

int                 scols_table_enable_export           (struct libscols_table *tb,
                                                         int enable);

Enable/disable export output format (COLUMNAME="value" ...). The parsable output formats (export and raw) are mutually exclusive.

scols_table_enable_maxout ()

int                 scols_table_enable_maxout           (struct libscols_table *tb,
                                                         int enable);

The extra space after last column is ignored by default. The output maximization use the extra space for all columns.

scols_table_enable_noheadings ()

int                 scols_table_enable_noheadings       (struct libscols_table *tb,
                                                         int enable);

Enable/disable header line.

scols_table_enable_raw ()

int                 scols_table_enable_raw              (struct libscols_table *tb,
                                                         int enable);

Enable/disable raw output format. The parsable output formats (export and raw) are mutually exclusive.

scols_table_get_column ()

struct libscols_column * scols_table_get_column         (struct libscols_table *tb,
                                                         size_t n);

scols_table_get_column_separator ()

char *              scols_table_get_column_separator    (struct libscols_table *tb);

scols_table_get_line ()

struct libscols_line * scols_table_get_line             (struct libscols_table *tb,
                                                         size_t n);

This is a shortcut for

ln = scols_new_line(); scols_line_set_....(cl, ...); scols_table_add_line(tb, ln);

scols_table_get_line_separator ()

char *              scols_table_get_line_separator      (struct libscols_table *tb);

scols_table_get_ncols ()

int                 scols_table_get_ncols               (struct libscols_table *tb);

scols_table_get_nlines ()

int                 scols_table_get_nlines              (struct libscols_table *tb);

scols_table_get_stream ()

FILE *              scols_table_get_stream              (struct libscols_table *tb);

Gets the output stream for table tb.

scols_table_is_ascii ()

int                 scols_table_is_ascii                (struct libscols_table *tb);

scols_table_is_empty ()

int                 scols_table_is_empty                (struct libscols_table *tb);

scols_table_is_export ()

int                 scols_table_is_export               (struct libscols_table *tb);

scols_table_is_maxout ()

int                 scols_table_is_maxout               (struct libscols_table *tb);

scols_table_is_noheadings ()

int                 scols_table_is_noheadings           (struct libscols_table *tb);

scols_table_is_raw ()

int                 scols_table_is_raw                  (struct libscols_table *tb);

scols_table_is_tree ()

int                 scols_table_is_tree                 (struct libscols_table *tb);

scols_table_new_column ()

struct libscols_column * scols_table_new_column         (struct libscols_table *tb,
                                                         const char *name,
                                                         double whint,
                                                         int flags);

This is shortcut for

cl = scols_new_column(); scols_column_set_....(cl, ...); scols_table_add_column(tb, cl);

The column width is possible to define by three ways:

whint = 0..1 : relative width, percent of terminal width

whint = 1..N : absolute width, empty colum will be truncated to the column header width

whint = 1..N

The column is necessary to address by sequential number. The first defined column has the colnum = 0. For example:

scols_table_new_column(tab, "FOO", 0.5, 0); // colnum = 0 scols_table_new_column(tab, "BAR", 0.5, 0); // colnum = 1 . . scols_line_get_cell(line, 0); // FOO column scols_line_get_cell(line, 1); // BAR column

scols_table_new_line ()

struct libscols_line * scols_table_new_line             (struct libscols_table *tb,
                                                         struct libscols_line *parent);

This is shortcut for

ln = scols_new_line(); scols_table_add_line(tb, ln); scols_line_add_child(parent, ln);

scols_table_next_column ()

int                 scols_table_next_column             (struct libscols_table *tb,
                                                         struct libscols_iter *itr,
                                                         struct libscols_column **cl);

Returns the next column of tb via cl.

scols_table_next_line ()

int                 scols_table_next_line               (struct libscols_table *tb,
                                                         struct libscols_iter *itr,
                                                         struct libscols_line **ln);

Finds the next line and returns a pointer to it via ln.

scols_table_reduce_termwidth ()

int                 scols_table_reduce_termwidth        (struct libscols_table *tb,
                                                         size_t reduce);

Reduce the output width to reduce.

scols_table_remove_column ()

int                 scols_table_remove_column           (struct libscols_table *tb,
                                                         struct libscols_column *cl);

Removes cl from tb.

scols_table_remove_columns ()

int                 scols_table_remove_columns          (struct libscols_table *tb);

Removes all of tb's columns.

scols_table_remove_line ()

int                 scols_table_remove_line             (struct libscols_table *tb,
                                                         struct libscols_line *ln);

Note that this function does not destroy the parent<->child relationship between lines. You have to call scols_line_remove_child()

scols_table_remove_lines ()

void                scols_table_remove_lines            (struct libscols_table *tb);

This empties the table and also destroys all the parent<->child relationships.

scols_table_set_column_separator ()

int                 scols_table_set_column_separator    (struct libscols_table *tb,
                                                         const char *sep);

Sets the column separator of tb to sep. Please note that sep should always take up a single cell in the output.

scols_table_set_line_separator ()

int                 scols_table_set_line_separator      (struct libscols_table *tb,
                                                         const char *sep);

Sets the line separator of tb to sep.

scols_table_set_stream ()

int                 scols_table_set_stream              (struct libscols_table *tb,
                                                         FILE *stream);

Sets the output stream for table tb.

scols_table_set_symbols ()

int                 scols_table_set_symbols             (struct libscols_table *tb,
                                                         struct libscols_symbols *sy);

Add a reference to sy from the table. The symbols are used by library to draw tree output. If no symbols are specified then library checks the current environment to select ASCII or UTF8 symbols. This default behavior could be controlled by scols_table_enable_ascii().

scols_sort_table ()

int                 scols_sort_table                    (struct libscols_table *tb,
                                                         struct libscols_column *cl);

Orders the table by the column. See also scols_column_set_cmpfunc().

scols_unref_table ()

void                scols_unref_table                   (struct libscols_table *tb);

Decreases the refcount of tb. When the count falls to zero, the instance is automatically deallocated.