2 * UCW Library -- Table printer
4 * (c) 2014 Robert Kessl <robert.kessl@economia.cz>
10 #include <ucw/fastbuf.h>
11 #include <ucw/mempool.h>
12 #include <ucw/xtypes.h>
14 // FIXME: update these macros
15 #ifdef CONFIG_UCW_CLEAN_ABI
16 #define table_append_bool ucw_table_append_bool
17 #define table_append_double ucw_table_append_double
18 #define table_append_int ucw_table_append_int
19 #define table_append_intmax ucw_table_append_intmax
20 #define table_append_printf ucw_table_append_printf
21 #define table_append_str ucw_table_append_str
22 #define table_append_u64 ucw_table_append_u64
23 #define table_append_uint ucw_table_append_uint
24 #define table_append_uintmax ucw_table_append_uintmax
25 #define table_cleanup ucw_table_cleanup
26 #define table_col_bool ucw_table_col_bool
27 #define table_col_bool_fmt ucw_table_col_bool_fmt
28 #define table_col_bool_name ucw_table_col_bool_name
29 #define table_col_double ucw_table_col_double
30 #define table_col_double_fmt ucw_table_col_double_fmt
31 #define table_col_double_name ucw_table_col_double_name
32 #define table_col_fbend ucw_table_col_fbend
33 #define table_col_fbstart ucw_table_col_fbstart
34 #define table_col_int ucw_table_col_int
35 #define table_col_int_fmt ucw_table_col_int_fmt
36 #define table_col_int_name ucw_table_col_int_name
37 #define table_col_intmax ucw_table_col_intmax
38 #define table_col_intmax_fmt ucw_table_col_intmax_fmt
39 #define table_col_intmax_name ucw_table_col_intmax_name
40 #define table_col_printf ucw_table_col_printf
41 #define table_col_s64 ucw_table_col_s64
42 #define table_col_s64_fmt ucw_table_col_s64_fmt
43 #define table_col_s64_name ucw_table_col_s64_name
44 #define table_col_str ucw_table_col_str
45 #define table_col_str_fmt ucw_table_col_str_fmt
46 #define table_col_str_name ucw_table_col_str_name
47 #define table_col_u64 ucw_table_col_u64
48 #define table_col_u64_fmt ucw_table_col_u64_fmt
49 #define table_col_u64_name ucw_table_col_u64_name
50 #define table_col_uint ucw_table_col_uint
51 #define table_col_uint_fmt ucw_table_col_uint_fmt
52 #define table_col_uint_name ucw_table_col_uint_name
53 #define table_col_uintmax ucw_table_col_uintmax
54 #define table_col_uintmax_fmt ucw_table_col_uintmax_fmt
55 #define table_col_uintmax_name ucw_table_col_uintmax_name
56 #define table_end ucw_table_end
57 #define table_end_row ucw_table_end_row
58 #define table_fmt_blockline ucw_table_fmt_blockline
59 #define table_fmt_human_readable ucw_table_fmt_human_readable
60 #define table_fmt_machine_readable ucw_table_fmt_machine_readable
61 #define table_get_col_idx ucw_table_get_col_idx
62 #define table_get_col_list ucw_table_get_col_list
63 #define table_init ucw_table_init
64 #define table_set_col_order ucw_table_set_col_order
65 #define table_set_col_order_by_name ucw_table_set_col_order_by_name
66 #define table_set_formatter ucw_table_set_formatter
67 #define table_set_gary_options ucw_table_set_gary_options
68 #define table_set_option ucw_table_set_option
69 #define table_set_option_value ucw_table_set_option_value
70 #define table_start ucw_table_start
78 // FIXME: update documentation according to the changes made in recent commits!
80 /** Types of columns. These are seldom used explicitly, using a column definition macro is preferred. **/
82 #define COL_TYPE_STR &xt_str
83 #define COL_TYPE_INT &xt_int
84 #define COL_TYPE_S64 &xt_s64
85 #define COL_TYPE_INTMAX &xt_intmax
86 #define COL_TYPE_UINT &xt_uint
87 #define COL_TYPE_U64 &xt_u64
88 #define COL_TYPE_UINTMAX &xt_uintmax
89 #define COL_TYPE_BOOL &xt_bool
90 #define COL_TYPE_DOUBLE &xt_double
91 #define COL_TYPE_ANY NULL
93 /** Justify cell contents to the left. **/
94 #define CELL_ALIGN_LEFT (1U << 31)
96 // CELL_FLAG_MASK has 1's in bits used for column flags,
97 // CELL_WIDTH_MASK has 1's in bits used for column width.
98 #define CELL_FLAG_MASK (CELL_ALIGN_LEFT)
99 #define CELL_WIDTH_MASK (~CELL_FLAG_MASK)
104 * Definition of a single table column.
105 * Usually, this is generated using the `TABLE_COL_`'type' macros.
106 * Fields marked with `[*]` are user-accessible.
108 struct table_column {
109 const char *name; // [*] Name of the column displayed in table header
110 int width; // [*] Width of the column (in characters) OR'ed with column flags
112 int first_column; // head of linked list of columns of this type
113 const struct xtype *type_def;
115 bool (*set_col_instance_option)(struct table *tbl, uint col, const char *value, char **err);
116 // [*] process table option for a column instance
119 // FIXME: is it correct to have idx and col_def? idx is sufficient and in fact a duplicity of idx
120 // idx is used only for initialization and col_def is used in other cases
121 struct table_col_instance {
122 uint idx; // idx is a index into struct table::columns
123 struct table_column *col_def; // this is pointer to the column definition, located in the array struct table::columns
124 const char *cell_content; // content of the cell of the current row
125 int next_column; // index of next column in linked list of columns of the same type
126 enum xtype_fmt output_type; // format of this column
130 * Definition of a table. Contains column definitions, and some per-table settings.
131 * Please use only fields marked with `[*]`.
133 struct table_template {
134 struct table_column *columns; // [*] Definition of columns
135 struct table_col_instance *column_order; // [*] Order of the columns in the print-out of the table
136 uint cols_to_output; // [*] Number of columns that are printed
137 const char *col_delimiter; // [*] Delimiter that is placed between columns
138 // Back-end used for table formatting and its private data
139 struct table_formatter *formatter;
143 * Handle of a table. Contains column definitions, per-table settings
144 * and internal data. To change the table definition, please use only
145 * fields marked with `[*]`.
148 struct table_column *columns; // [*] Definition of columns
149 int column_count; // [*] Number of columns (calculated by table_init())
150 struct mempool *pool; // Memory pool used for storing table data. Contains global state
151 // and data of the current row.
152 struct mempool_state pool_state; // State of the pool after the table is initialized, i.e., before
153 // per-row data have been allocated.
155 struct table_col_instance *column_order; // [*] Order of the columns in the print-out of the table
156 uint cols_to_output; // [*] Number of columns that are printed
157 const char *col_delimiter; // [*] Delimiter that is placed between columns
158 uint print_header; // [*] 0 indicates that table header should not be printed
160 struct fastbuf *out; // [*] Fastbuffer to which the table is printed
161 int last_printed_col; // Index of the last column which was set. -1 indicates start of row.
162 // Used for example for appending to the current column.
163 int row_printing_started; // Indicates that a row has been started. Duplicates last_printed_col, but harmlessly.
164 struct fbpool fb_col_out; // Per-cell fastbuf, see table_col_fbstart()
165 int col_out; // Index of the column that is currently printed using fb_col_out
167 // Back-end used for table formatting and its private data
168 struct table_formatter *formatter;
173 * In most cases, table descriptions are constructed using the following macros.
174 * See the examples above for more details.
176 * * `TBL_COLUMNS` indicates the start of definition of columns
177 * * `TBL_COL_`'type'`(name, width)` defines a column of a given type
178 * * `TBL_COL_`'type'`_FMT(name, width, fmt)` defines a column with a custom format string
179 * * `TBL_COL_END` ends the column definitions
180 * * `TBL_COL_ORDER` specifies custom ordering of columns in the output
181 * * `TBL_COL_DELIMITER` and `TBL_APPEND_DELIMITER` override default delimiters
182 * * `TBL_OUTPUT_HUMAN_READABLE` requests human-readable formatting (this is the default)
183 * * `TBL_OUTPUT_MACHINE_READABLE` requests machine-readable TSV output
184 * * `TBL_OUTPUT_BLOCKLINE` requests block formatting (each cell printed a pair of a key and value on its own line)
188 #define TBL_COL_LIST_INIT .first_column = -1
189 #define TBL_COL_STR(_name, _width) { .name = _name, .width = _width, .fmt = XTYPE_FMT_DEFAULT, .type_def = COL_TYPE_STR, TBL_COL_LIST_INIT }
190 #define TBL_COL_INT(_name, _width) { .name = _name, .width = _width, .fmt = XTYPE_FMT_DEFAULT, .type_def = COL_TYPE_INT, TBL_COL_LIST_INIT }
191 #define TBL_COL_S64(_name, _width) { .name = _name, .width = _width, .fmt = XTYPE_FMT_DEFAULT, .type_def = COL_TYPE_S64, TBL_COL_LIST_INIT }
192 #define TBL_COL_UINT(_name, _width) { .name = _name, .width = _width, .fmt = XTYPE_FMT_DEFAULT, .type_def = COL_TYPE_UINT, TBL_COL_LIST_INIT }
193 #define TBL_COL_U64(_name, _width) { .name = _name, .width = _width, .fmt = XTYPE_FMT_DEFAULT, .type_def = COL_TYPE_U64, TBL_COL_LIST_INIT }
194 #define TBL_COL_INTMAX(_name, _width) { .name = _name, .width = _width, .fmt = XTYPE_FMT_DEFAULT, .type_def = COL_TYPE_INTMAX, TBL_COL_LIST_INIT }
195 #define TBL_COL_UINTMAX(_name, _width) { .name = _name, .width = _width, .fmt = XTYPE_FMT_DEFAULT, .type_def = COL_TYPE_UINTMAX, TBL_COL_LIST_INIT }
196 #define TBL_COL_HEXUINT(_name, _width) { .name = _name, .width = _width, .fmt = XTYPE_FMT_DEFAULT, .type_def = COL_TYPE_UINT, TBL_COL_LIST_INIT }
197 #define TBL_COL_DOUBLE(_name, _width, _prec) { .name = _name, .width = _width, .fmt = XTYPE_FMT_DEFAULT, .type_def = COL_TYPE_DOUBLE, TBL_COL_LIST_INIT }
198 #define TBL_COL_BOOL(_name, _width) { .name = _name, .width = _width, .fmt = XTYPE_FMT_DEFAULT, .type_def = COL_TYPE_BOOL, TBL_COL_LIST_INIT }
199 #define TBL_COL_ANY(_name, _width) { .name = _name, .width = _width, .fmt = XTYPE_FMT_DEFAULT, .type_def = COL_TYPE_ANY, TBL_COL_LIST_INIT }
200 #define TBL_COL_CUSTOM(_name, _width, _xtype) { .name = _name, .width = _width, .fmt = XTYPE_FMT_DEFAULT, .type_def = _xtype, TBL_COL_LIST_INIT }
202 #define TBL_COL_STR_FMT(_name, _width, _fmt) { .name = _name, .width = _width, .fmt = _fmt, .type_def = COL_TYPE_STR, TBL_COL_LIST_INIT }
203 #define TBL_COL_INT_FMT(_name, _width, _fmt) { .name = _name, .width = _width, .fmt = _fmt, .type_def = COL_TYPE_INT, TBL_COL_LIST_INIT }
204 #define TBL_COL_S64_FMT(_name, _width, _fmt) { .name = _name, .width = _width, .fmt = _fmt, .type_def = COL_TYPE_S64, TBL_COL_LIST_INIT }
205 #define TBL_COL_UINT_FMT(_name, _width, _fmt) { .name = _name, .width = _width, .fmt = _fmt, .type_def = COL_TYPE_UINT, TBL_COL_LIST_INIT }
206 #define TBL_COL_U64_FMT(_name, _width, _fmt) { .name = _name, .width = _width, .fmt = _fmt, .type_def = COL_TYPE_U64, TBL_COL_LIST_INIT }
207 #define TBL_COL_INTMAX_FMT(_name, _width, _fmt) { .name = _name, .width = _width, .fmt = _fmt, .type_def = COL_TYPE_INTMAX, TBL_COL_LIST_INIT }
208 #define TBL_COL_UINTMAX_FMT(_name, _width, _fmt) { .name = _name, .width = _width, .fmt = _fmt, .type_def = COL_TYPE_UINTMAX, TBL_COL_LIST_INIT }
209 #define TBL_COL_HEXUINT_FMT(_name, _width, _fmt) { .name = _name, .width = _width, .fmt = _fmt, .type_def = COL_TYPE_UINT, TBL_COL_LIST_INIT }
210 #define TBL_COL_BOOL_FMT(_name, _width, _fmt) { .name = _name, .width = _width, .fmt = _fmt, .type_def = COL_TYPE_BOOL, TBL_COL_LIST_INIT }
212 #define TBL_COL_END { .name = 0, .width = 0, .fmt = 0, .type_def = NULL }
214 #define TBL_COLUMNS .columns = (struct table_column [])
215 #define TBL_COL_ORDER(order) .column_order = (struct table_col_instance *) order, .cols_to_output = ARRAY_SIZE(order)
216 #define TBL_COL_DELIMITER(_delimiter_) .col_delimiter = _delimiter_
217 #define TBL_COL(_idx) { .idx = _idx, .output_type = XTYPE_FMT_DEFAULT, .next_column = -1 }
218 #define TBL_COL_FMT(_idx, _fmt) { .idx = _idx, .output_type = XTYPE_FMT_DEFAULT, .next_column = -1, .fmt = _fmt }
219 #define TBL_COL_TYPE(_idx, _type) { .idx = _idx, .output_type = _type, .next_column = -1 }
221 #define TBL_OUTPUT_HUMAN_READABLE .formatter = &table_fmt_human_readable
222 #define TBL_OUTPUT_BLOCKLINE .formatter = &table_fmt_blockline
223 #define TBL_OUTPUT_MACHINE_READABLE .formatter = &table_fmt_machine_readable
225 #define TBL_COL_ITER_START(_tbl, _colidx, _var, _idxval) { struct table_col_instance *_var = NULL; int _idxval = _tbl->columns[_colidx].first_column; \
226 for(_idxval = _tbl->columns[_colidx].first_column, _var = _tbl->column_order + _idxval; _idxval != -1; _idxval = _tbl->column_order[_idxval].next_column, _var = _tbl->column_order + _idxval)
228 #define TBL_COL_ITER_END }
231 * Creates a new table from a table template. The template should already contain
232 * the definitions of columns.
234 struct table *table_init(const struct table_template *tbl_template);
236 /** Destroy a table definition, freeing all memory used by it. **/
237 void table_cleanup(struct table *tbl);
240 * Start printing of a table. This is a prerequisite to setting of column values.
241 * After @table_start() is called, it is no longer possible to change parameters
242 * of the table by `table_set_`'something' nor by direct access to the table structure.
244 void table_start(struct table *tbl, struct fastbuf *out);
247 * This function must be called after all the rows of the current table are printed,
248 * making the table structure ready for the next table. You can call `table_set_`'something'
249 * between @table_end() and @table_start().
251 void table_end(struct table *tbl);
254 * Filling tables with data
255 * ------------------------
257 * For each column type, there are functions for filling of cells
258 * of the particular type:
260 * * `table_col_`'type'`(table, idx, value)` sets the cell in column `idx`
262 * * `table_col_`'type'`_fmt(table, idx, fmt, ...)` does the same with
263 * a custom printf-like format string
264 * * `table_col_`'type'`_name(table, name, value)` refers to the column
265 * by its name instead of its index.
266 * * `table_append_`'type'`(table, value)` appends a value to the most
267 * recently accessed cell.
270 #define TABLE_COL_PROTO(_name_, _type_) void table_col_##_name_(struct table *tbl, int col, _type_ val);\
271 void table_col_##_name_##_name(struct table *tbl, const char *col_name, _type_ val);\
272 void table_col_##_name_##_fmt(struct table *tbl, int col, enum xtype_fmt fmt, _type_ val);
274 // table_col_<type>_fmt has one disadvantage: it is not possible to
275 // check whether fmt contains format that contains formatting that is
276 // compatible with _type_
278 TABLE_COL_PROTO(int, int);
279 TABLE_COL_PROTO(uint, uint);
280 TABLE_COL_PROTO(double, double);
281 TABLE_COL_PROTO(str, const char *);
282 TABLE_COL_PROTO(intmax, intmax_t);
283 TABLE_COL_PROTO(uintmax, uintmax_t);
284 TABLE_COL_PROTO(s64, s64);
285 TABLE_COL_PROTO(u64, u64);
286 TABLE_COL_PROTO(bool, bool);
288 /** macros that enables easy definitions of bodies of table_col_<something> functions **/
290 #define TABLE_COL(_name_, _type_, _typeconst_) void table_col_##_name_(struct table *tbl, int col, _type_ val)\
292 enum xtype_fmt fmt = tbl->columns[col].fmt;\
293 table_col_##_name_##_fmt(tbl, col, fmt, val);\
296 #define TABLE_COL_STR(_name_, _type_, _typeconst_) void table_col_##_name_##_name(struct table *tbl, const char *col_name, _type_ val)\
298 int col = table_get_col_idx(tbl, col_name);\
299 table_col_##_name_(tbl, col, val);\
302 #define TABLE_COL_FMT(_name_, _type_, _typeconst_) void table_col_##_name_##_fmt(struct table *tbl, int col, enum xtype_fmt fmt, _type_ val) \
304 ASSERT_MSG(col < tbl->column_count && col >= 0, "Table column %d does not exist.", col);\
305 ASSERT(tbl->columns[col].type_def == COL_TYPE_ANY || _typeconst_ == tbl->columns[col].type_def);\
306 tbl->last_printed_col = col;\
307 tbl->row_printing_started = 1;\
308 const char *cell_content = NULL;\
309 if(tbl->columns[col].type_def != COL_TYPE_ANY) cell_content = tbl->columns[col].type_def->format(&val, fmt, tbl->pool);\
310 else cell_content = (_typeconst_)->format(&val, fmt, tbl->pool);\
311 table_set_all_inst_content(tbl, col, cell_content);\
314 #define TABLE_COL_BODIES(_name_, _type_, _typeconst_) TABLE_COL(_name_, _type_, _typeconst_); \
315 TABLE_COL_STR(_name_, _type_, _typeconst_);\
316 TABLE_COL_FMT(_name_, _type_, _typeconst_);
318 // FIXME: the next line was removed, the question is whether it should
319 // be there currently it is impossible to undef the macro.
320 // #undef TABLE_COL_PROTO
323 * Set a particular cell of the current row to a string formatted
324 * by sprintf(). This function can set a column of an arbitrary type.
326 void table_col_printf(struct table *tbl, int col, const char *fmt, ...) FORMAT_CHECK(printf, 3, 4);
329 * Alternatively, a string cell can be constructed as a stream.
330 * This function creates a fastbuf stream connected to the contents
331 * of the particular cell. Before you close the stream by @table_col_fbend(),
332 * no other operations with cells are allowed.
334 struct fastbuf *table_col_fbstart(struct table *tbl, int col);
337 * Close the stream that is used for printing of the current column.
339 void table_col_fbend(struct table *tbl);
342 * Called when all cells of the current row have their values filled in.
343 * It sends the completed row to the output stream.
345 void table_end_row(struct table *tbl);
348 * Resets data in current row.
350 void table_reset_row(struct table *tbl);
353 * Configuration functions
354 * -----------------------
358 * Find the index of a column with name @col_name. Returns -1 if there is no such column.
360 int table_get_col_idx(struct table *tbl, const char *col_name);
364 * Sets a string argument to a column instance
366 bool table_set_col_opt_default(struct table *tbl, int col_idx, const char *col_arg, char ** err);
369 * Returns a comma-and-space-separated list of column names, allocated from table's internal
372 const char *table_get_col_list(struct table *tbl);
375 * Sets the order in which the columns are printed. The @col_order parameter is used until @table_end() or
376 * @table_cleanup() is called. The table stores only the pointer and the memory pointed to by @col_order is
377 * allocated and deallocated by the caller.
379 void table_set_col_order(struct table *tbl, int *col_order, int col_order_size);
382 * Returns 1 if col_idx will be printed, 0 otherwise.
384 bool table_col_is_printed(struct table *tbl, uint col_idx);
387 * Sets the order in which the columns are printed. The specification is a string with comma-separated column
388 * names. Returns NULL for success and an error message otherwise. The string is not referenced after
389 * this function returns.
391 * The format of the col_order string is the following:
392 * <col-order-string> := <col-def>[,<col-def>]*
394 * <col-def> := <col-name> '[' <col-opt> ']'
396 * <col-name> is a string that does not contain comma ',' or '[',']' brackets
398 * <col-opt> is currently only one string.
400 * FIXME In the future, we should allow <col-opt> to be a comma(,) separated list of identifiers
402 const char *table_set_col_order_by_name(struct table *tbl, const char *col_order);
405 * Sets table formatter. See below for the list of formatters.
407 void table_set_formatter(struct table *tbl, struct table_formatter *fmt);
410 * Set a table option. All options have a key and a value. Currently,
411 * the following keys are defined (other keys can be accepted by formatters):
414 * |===================================================================================================
415 * | key | value | meaning
416 * | `header` | 0 or 1 | set whether a table header should be printed
417 * | `noheader` | 'none' | equivalent to `header`=0
418 * | `cols` | comma-separated column list | set order of columns
419 * | `fmt` | `human`/`machine`/`block` | set table formatter to one of the built-in formatters
420 * | `col-delim`| string | set column delimiter
421 * |===================================================================================================
423 const char *table_set_option_value(struct table *tbl, const char *key, const char *value);
426 * Sets a table option given as 'key'`:`'value' or 'key' (with no value).
428 const char *table_set_option(struct table *tbl, const char *opt);
431 * Sets several table option in 'key'`:`'value' form, stored in a growing array.
432 * This is frequently used for options given on the command line.
434 const char *table_set_gary_options(struct table *tbl, char **gary_table_opts);
440 * Transformation of abstract cell data to the characters in the output stream
441 * is under control of a formatter (which serves as a back-end of the table printer).
442 * There are several built-in formatters, but you can define your own.
444 * A formatter is described by a structure, which contains pointers to several
445 * call-back functions, which are called by the table printer at specific occasions.
447 * The formatter can keep its internal state in the `data` field of `struct table`
448 * and allocate temporary data from the table's memory pool. Memory allocated in
449 * the `row_output` call-back is freed before the next row begins. Memory allocated
450 * between the beginning of `table_start` and the end of `table_end` is freed after
451 * `table_end`. Memory allocated by `process_option` when no table is started
452 * is kept until @table_cleanup().
455 /** Definition of a formatter back-end. **/
456 struct table_formatter {
457 void (*row_output)(struct table *tbl); // [*] Function that outputs one row
458 void (*table_start)(struct table *tbl); // [*] table_start callback (optional)
459 void (*table_end)(struct table *tbl); // [*] table_end callback (optional)
460 bool (*process_option)(struct table *tbl, const char *key, const char *value, const char **err);
461 // [*] Process table option and possibly return an error message (optional)
464 /** Standard formatter for human-readable output. **/
465 extern struct table_formatter table_fmt_human_readable;
467 /** Standard formatter for machine-readable output (tab-separated values). **/
468 extern struct table_formatter table_fmt_machine_readable;
471 * Standard formatter for block output. Each cell is output on its own line
472 * of the form `column_name: value`. Rows are separated by blank lines.
474 extern struct table_formatter table_fmt_blockline;