ucw/table.h

   1 /*
   2  *      UCW Library -- Table printer
   3  *
   4  *      (c) 2014 Robert Kessl <robert.kessl@economia.cz>
   5  */
   6
   7 #ifndef _UCW_TABLE_H
   8 #define _UCW_TABLE_H
   9
  10 #include <ucw/fastbuf.h>
  11 #include <ucw/mempool.h>
  12
  13 #ifdef CONFIG_UCW_CLEAN_ABI
  14 #define table_append_bool ucw_table_append_bool
  15 #define table_append_double ucw_table_append_double
  16 #define table_append_int ucw_table_append_int
  17 #define table_append_intmax ucw_table_append_intmax
  18 #define table_append_printf ucw_table_append_printf
  19 #define table_append_str ucw_table_append_str
  20 #define table_append_u64 ucw_table_append_u64
  21 #define table_append_uint ucw_table_append_uint
  22 #define table_append_uintmax ucw_table_append_uintmax
  23 #define table_cleanup ucw_table_cleanup
  24 #define table_col_bool ucw_table_col_bool
  25 #define table_col_bool_fmt ucw_table_col_bool_fmt
  26 #define table_col_bool_name ucw_table_col_bool_name
  27 #define table_col_double ucw_table_col_double
  28 #define table_col_double_fmt ucw_table_col_double_fmt
  29 #define table_col_double_name ucw_table_col_double_name
  30 #define table_col_fbend ucw_table_col_fbend
  31 #define table_col_fbstart ucw_table_col_fbstart
  32 #define table_col_int ucw_table_col_int
  33 #define table_col_int_fmt ucw_table_col_int_fmt
  34 #define table_col_int_name ucw_table_col_int_name
  35 #define table_col_intmax ucw_table_col_intmax
  36 #define table_col_intmax_fmt ucw_table_col_intmax_fmt
  37 #define table_col_intmax_name ucw_table_col_intmax_name
  38 #define table_col_printf ucw_table_col_printf
  39 #define table_col_s64 ucw_table_col_s64
  40 #define table_col_s64_fmt ucw_table_col_s64_fmt
  41 #define table_col_s64_name ucw_table_col_s64_name
  42 #define table_col_str ucw_table_col_str
  43 #define table_col_str_fmt ucw_table_col_str_fmt
  44 #define table_col_str_name ucw_table_col_str_name
  45 #define table_col_u64 ucw_table_col_u64
  46 #define table_col_u64_fmt ucw_table_col_u64_fmt
  47 #define table_col_u64_name ucw_table_col_u64_name
  48 #define table_col_uint ucw_table_col_uint
  49 #define table_col_uint_fmt ucw_table_col_uint_fmt
  50 #define table_col_uint_name ucw_table_col_uint_name
  51 #define table_col_uintmax ucw_table_col_uintmax
  52 #define table_col_uintmax_fmt ucw_table_col_uintmax_fmt
  53 #define table_col_uintmax_name ucw_table_col_uintmax_name
  54 #define table_end ucw_table_end
  55 #define table_end_row ucw_table_end_row
  56 #define table_fmt_blockline ucw_table_fmt_blockline
  57 #define table_fmt_human_readable ucw_table_fmt_human_readable
  58 #define table_fmt_machine_readable ucw_table_fmt_machine_readable
  59 #define table_get_col_idx ucw_table_get_col_idx
  60 #define table_get_col_list ucw_table_get_col_list
  61 #define table_init ucw_table_init
  62 #define table_set_col_order ucw_table_set_col_order
  63 #define table_set_col_order_by_name ucw_table_set_col_order_by_name
  64 #define table_set_formatter ucw_table_set_formatter
  65 #define table_set_gary_options ucw_table_set_gary_options
  66 #define table_set_option ucw_table_set_option
  67 #define table_set_option_value ucw_table_set_option_value
  68 #define table_start ucw_table_start
  69 #endif
  70
  71 /***
  72  * Table definitions
  73  * -----------------
  74  ***/
  75
  76 /** Types of columns. These are seldom used explicitly, using a column definition macro is preferred. **/
  77 enum column_type {
  78   COL_TYPE_STR,         // String
  79   COL_TYPE_INT,         // int
  80   COL_TYPE_S64,         // Signed 64-bit integer
  81   COL_TYPE_INTMAX,      // intmax_t
  82   COL_TYPE_UINT,        // unsigned int
  83   COL_TYPE_U64,         // Unsigned 64-bit integer
  84   COL_TYPE_UINTMAX,     // uintmax_t
  85   COL_TYPE_BOOL,        // bool
  86   COL_TYPE_DOUBLE,      // double
  87   COL_TYPE_ANY,         // Any type
  88   COL_TYPE_LAST
  89 };
  90
  91 /** Justify cell contents to the left. **/
  92 #define CELL_ALIGN_LEFT     (1U << 31)
  93
  94 // CELL_FLAG_MASK has 1's in bits used for column flags,
  95 // CELL_WIDTH_MASK has 1's in bits used for column width.
  96 #define CELL_FLAG_MASK  (CELL_ALIGN_LEFT)
  97 #define CELL_WIDTH_MASK (~CELL_FLAG_MASK)
  98
  99 /**
 100  * Definition of a single table column.
 101  * Usually, this is generated using the `TABLE_COL_`'type' macros.
 102  * Fields marked with `[*]` are user-accessible.
 103  **/
 104 struct table_column {
 105   const char *name;             // [*] Name of the column displayed in table header
 106   int width;                    // [*] Width of the column (in characters) OR'ed with column flags
 107   const char *fmt;              // [*] Default format of each cell in the column
 108   enum column_type type;        // [*] Type of the cells in the column
 109 };
 110
 111 /**
 112  * Definition of a table. Contains column definitions, per-table settings
 113  * and internal data. Please use only fields marked with `[*]`.
 114  **/
 115 struct table {
 116   struct table_column *columns;         // [*] Definition of columns
 117   int column_count;                     // [*] Number of columns (calculated by table_init())
 118   struct mempool *pool;                 // Memory pool used for storing table data. Contains global state
 119                                         // and data of the current row.
 120   struct mempool_state pool_state;      // State of the pool after the table is initialized, i.e., before
 121                                         // per-row data have been allocated.
 122
 123   char **col_str_ptrs;                  // Values of cells in the current row (allocated from the pool)
 124
 125   uint *column_order;                   // [*] Order of the columns in the print-out of the table
 126   uint cols_to_output;                  // [*] Number of columns that are printed
 127   const char *col_delimiter;            // [*] Delimiter that is placed between columns
 128   const char *append_delimiter;         // [*] Separator of multiple values in a single cell (see table_append_...())
 129   uint print_header;                    // [*] 0 indicates that table header should not be printed
 130
 131   struct fastbuf *out;                  // [*] Fastbuffer to which the table is printed
 132   int last_printed_col;                 // Index of the last column which was set. -1 indicates start of row.
 133                                         // Used for example for appending to the current column.
 134   int row_printing_started;             // Indicates that a row has been started. Duplicates last_printed_col, but harmlessly.
 135   struct fbpool fb_col_out;             // Per-cell fastbuf, see table_col_fbstart()
 136   int col_out;                          // Index of the column that is currently printed using fb_col_out
 137
 138   // Back-end used for table formatting and its private data
 139   struct table_formatter *formatter;
 140   void *data;
 141 };
 142
 143 /****
 144  * In most cases, table descriptions are constructed using the following macros.
 145  * See the examples above for more details.
 146  *
 147  *  * `TBL_COLUMNS` indicates the start of definition of columns
 148  *  * `TBL_COL_`'type'`(name, width)` defines a column of a given type
 149  *  * `TBL_COL_`'type'`_FMT(name, width, fmt)` defines a column with a custom format string
 150  *  * `TBL_COL_END` ends the column definitions
 151  *  * `TBL_COL_ORDER` specifies custom ordering of columns in the output
 152  *  * `TBL_COL_DELIMITER` and `TBL_APPEND_DELIMITER` override default delimiters
 153  *  * `TBL_OUTPUT_HUMAN_READABLE` requests human-readable formatting (this is the default)
 154  *  * `TBL_OUTPUT_MACHINE_READABLE` requests machine-readable TSV output
 155  *  * `TBL_OUTPUT_BLOCKLINE` requests block formatting (each cell printed a pair of a key and value on its own line)
 156  *
 157  ***/
 158
 159 #define TBL_COL_STR(_name, _width)            { .name = _name, .width = _width, .fmt = "%s", .type = COL_TYPE_STR }
 160 #define TBL_COL_INT(_name, _width)            { .name = _name, .width = _width, .fmt = "%d", .type = COL_TYPE_INT }
 161 #define TBL_COL_S64(_name, _width)            { .name = _name, .width = _width, .fmt = "%lld", .type = COL_TYPE_S64 }
 162 #define TBL_COL_UINT(_name, _width)           { .name = _name, .width = _width, .fmt = "%u", .type = COL_TYPE_UINT }
 163 #define TBL_COL_U64(_name, _width)            { .name = _name, .width = _width, .fmt = "%llu", .type = COL_TYPE_U64 }
 164 #define TBL_COL_INTMAX(_name, _width)         { .name = _name, .width = _width, .fmt = "%jd", .type = COL_TYPE_INTMAX }
 165 #define TBL_COL_UINTMAX(_name, _width)        { .name = _name, .width = _width, .fmt = "%ju", .type = COL_TYPE_UINTMAX }
 166 #define TBL_COL_HEXUINT(_name, _width)        { .name = _name, .width = _width, .fmt = "0x%x", .type = COL_TYPE_UINT }
 167 #define TBL_COL_DOUBLE(_name, _width, _prec)  { .name = _name, .width = _width, .fmt = "%." #_prec "lf", .type = COL_TYPE_DOUBLE }
 168 #define TBL_COL_BOOL(_name, _width)           { .name = _name, .width = _width, .fmt = "%s", .type = COL_TYPE_BOOL }
 169 #define TBL_COL_ANY(_name, _width)            { .name = _name, .width = _width, .fmt = 0, .type = COL_TYPE_ANY }
 170
 171 #define TBL_COL_STR_FMT(_name, _width, _fmt)            { .name = _name, .width = _width, .fmt = _fmt, .type = COL_TYPE_STR }
 172 #define TBL_COL_INT_FMT(_name, _width, _fmt)            { .name = _name, .width = _width, .fmt = _fmt, .type = COL_TYPE_INT }
 173 #define TBL_COL_S64_FMT(_name, _width, _fmt)            { .name = _name, .width = _width, .fmt = _fmt, .type = COL_TYPE_S64 }
 174 #define TBL_COL_UINT_FMT(_name, _width, _fmt)           { .name = _name, .width = _width, .fmt = _fmt, .type = COL_TYPE_UINT }
 175 #define TBL_COL_U64_FMT(_name, _width, _fmt)            { .name = _name, .width = _width, .fmt = _fmt, .type = COL_TYPE_U64 }
 176 #define TBL_COL_INTMAX_FMT(_name, _width, _fmt)         { .name = _name, .width = _width, .fmt = _fmt, .type = COL_TYPE_INTMAX }
 177 #define TBL_COL_UINTMAX_FMT(_name, _width, _fmt)        { .name = _name, .width = _width, .fmt = _fmt, .type = COL_TYPE_UINTMAX }
 178 #define TBL_COL_HEXUINT_FMT(_name, _width, _fmt)        { .name = _name, .width = _width, .fmt = _fmt, .type = COL_TYPE_UINT }
 179 #define TBL_COL_BOOL_FMT(_name, _width, _fmt)           { .name = _name, .width = _width, .fmt = _fmt, .type = COL_TYPE_BOOL }
 180
 181 #define TBL_COL_END { .name = 0, .width = 0, .fmt = 0, .type = COL_TYPE_LAST }
 182
 183 #define TBL_COLUMNS  .columns = (struct table_column [])
 184 #define TBL_COL_ORDER(order) .column_order = (int *) order, .cols_to_output = ARRAY_SIZE(order)
 185 #define TBL_COL_DELIMITER(_delimiter_) .col_delimiter = _delimiter_
 186 #define TBL_APPEND_DELIMITER(_delimiter_) .append_delimiter = _delimiter_
 187
 188 #define TBL_OUTPUT_HUMAN_READABLE     .formatter = &table_fmt_human_readable
 189 #define TBL_OUTPUT_BLOCKLINE          .formatter = &table_fmt_blockline
 190 #define TBL_OUTPUT_MACHINE_READABLE   .formatter = &table_fmt_machine_readable
 191
 192 /**
 193  * Initialize a table definition. The structure should already contain
 194  * the definitions of columns.
 195  **/
 196 void table_init(struct table *tbl);
 197
 198 /** Destroy a table definition, freeing all memory used by it. **/
 199 void table_cleanup(struct table *tbl);
 200
 201 /**
 202  * Start printing of a table. This is a prerequisite to setting of column values.
 203  * After @table_start() is called, it is no longer possible to change parameters
 204  * of the table by `table_set_`'something' nor by direct access to the table structure.
 205  **/
 206 void table_start(struct table *tbl, struct fastbuf *out);
 207
 208 /**
 209  * This function must be called after all the rows of the current table are printed,
 210  * making the table structure ready for the next table. You can call `table_set_`'something'
 211  * between @table_end() and @table_start().
 212  **/
 213 void table_end(struct table *tbl);
 214
 215 /***
 216  * Filling tables with data
 217  * ------------------------
 218  *
 219  * For each column type, there are functions for filling of cells
 220  * of the particular type:
 221  *
 222  *   * `table_col_`'type'`(table, idx, value)` sets the cell in column `idx`
 223  *     to the `value`
 224  *   * `table_col_`'type'`_fmt(table, idx, fmt, ...)` does the same with
 225  *     a custom printf-like format string
 226  *   * `table_col_`'type'`_name(table, name, value)` refers to the column
 227  *     by its name instead of its index.
 228  *   * `table_append_`'type'`(table, value)` appends a value to the most
 229  *     recently accessed cell.
 230  ***/
 231
 232 #define TABLE_COL_PROTO(_name_, _type_) void table_col_##_name_(struct table *tbl, int col, _type_ val);\
 233   void table_col_##_name_##_name(struct table *tbl, const char *col_name, _type_ val);\
 234   void table_col_##_name_##_fmt(struct table *tbl, int col, const char *fmt, _type_ val) FORMAT_CHECK(printf, 3, 0);
 235
 236 // table_col_<type>_fmt has one disadvantage: it is not possible to
 237 // check whether fmt contains format that contains formatting that is
 238 // compatible with _type_
 239
 240 TABLE_COL_PROTO(int, int);
 241 TABLE_COL_PROTO(uint, uint);
 242 TABLE_COL_PROTO(double, double);
 243 TABLE_COL_PROTO(str, const char *);
 244 TABLE_COL_PROTO(intmax, intmax_t);
 245 TABLE_COL_PROTO(uintmax, uintmax_t);
 246 TABLE_COL_PROTO(s64, s64);
 247 TABLE_COL_PROTO(u64, u64);
 248
 249 void table_col_bool(struct table *tbl, int col, uint val);
 250 void table_col_bool_name(struct table *tbl, const char *col_name, uint val);
 251 void table_col_bool_fmt(struct table *tbl, int col, const char *fmt, uint val);
 252 #undef TABLE_COL_PROTO
 253
 254 #define TABLE_APPEND_PROTO(_name_, _type_) void table_append_##_name_(struct table *tbl, _type_ val)
 255 TABLE_APPEND_PROTO(int, int);
 256 TABLE_APPEND_PROTO(uint, uint);
 257 TABLE_APPEND_PROTO(double, double);
 258 TABLE_APPEND_PROTO(str, const char *);
 259 TABLE_APPEND_PROTO(intmax, intmax_t);
 260 TABLE_APPEND_PROTO(uintmax, uintmax_t);
 261 TABLE_APPEND_PROTO(s64, s64);
 262 TABLE_APPEND_PROTO(u64, u64);
 263 void table_append_bool(struct table *tbl, int val);
 264 #undef TABLE_APPEND_PROTO
 265
 266 /**
 267  * Set a particular cell of the current row to a string formatted
 268  * by sprintf(). This function can set a column of an arbitrary type.
 269  **/
 270 void table_col_printf(struct table *tbl, int col, const char *fmt, ...) FORMAT_CHECK(printf, 3, 4);
 271
 272 /**
 273  * Append a string formatted by sprintf() to the most recently filled cell.
 274  * This function can work with columns of an arbitrary type.
 275  **/
 276 void table_append_printf(struct table *tbl, const char *fmt, ...) FORMAT_CHECK(printf, 2, 3);
 277
 278 /**
 279  * Alternatively, a string cell can be constructed as a stream.
 280  * This function creates a fastbuf stream connected to the contents
 281  * of the particular cell. Before you close the stream by @table_col_fbend(),
 282  * no other operations with cells are allowed.
 283  **/
 284 struct fastbuf *table_col_fbstart(struct table *tbl, int col);
 285
 286 /**
 287  * Close the stream that is used for printing of the current column.
 288  **/
 289 void table_col_fbend(struct table *tbl);
 290
 291 /**
 292  * Called when all cells of the current row have their values filled in.
 293  * It sends the completed row to the output stream.
 294  **/
 295 void table_end_row(struct table *tbl);
 296
 297 /***
 298  * Configuration functions
 299  * -----------------------
 300  ***/
 301
 302 /**
 303  * Find the index of a column with name @col_name. Returns -1 if there is no such column.
 304  **/
 305 int table_get_col_idx(struct table *tbl, const char *col_name);
 306
 307 /**
 308  * Returns a comma-and-space-separated list of column names, allocated from table's internal
 309  * memory pool.
 310  **/
 311 const char *table_get_col_list(struct table *tbl);
 312
 313 /**
 314  * Sets the order in which the columns are printed. The @col_order parameter is used until @table_end() or
 315  * @table_cleanup() is called. The table stores only the pointer and the memory pointed to by @col_order is
 316  * allocated and deallocated by the caller.
 317  **/
 318 void table_set_col_order(struct table *tbl, int *col_order, int col_order_size);
 319
 320 /**
 321  * Sets the order in which the columns are printed. The specification is a string with comma-separated column
 322  * names. Returns NULL for success and an error message otherwise. The string is not referenced after
 323  * this function returns.
 324  **/
 325 const char *table_set_col_order_by_name(struct table *tbl, const char *col_order);
 326
 327 /**
 328  * Sets table formatter. See below for the list of formatters.
 329  **/
 330 void table_set_formatter(struct table *tbl, struct table_formatter *fmt);
 331
 332 /**
 333  * Set a table option. All options have a key and a value. Currently,
 334  * the following keys are defined (other keys can be accepted by formatters):
 335  *
 336  * [options="header"]
 337  * |===================================================================================================
 338  * | key        | value                         | meaning
 339  * | `header`   | 0 or 1                        | set whether a table header should be printed
 340  * | `noheader` | 'none'                        | equivalent to `header`=0
 341  * | `cols`     | comma-separated column list   | set order of columns
 342  * | `fmt`      | `human`/`machine`/`block`     | set table formatter to one of the built-in formatters
 343  * | `col-delim`| string                        | set column delimiter
 344  * |===================================================================================================
 345  **/
 346 const char *table_set_option_value(struct table *tbl, const char *key, const char *value);
 347
 348 /**
 349  * Sets a table option given as 'key'`:`'value' or 'key' (with no value).
 350  **/
 351 const char *table_set_option(struct table *tbl, const char *opt);
 352
 353 /**
 354  * Sets several table option in 'key'`:`'value' form, stored in a growing array.
 355  * This is frequently used for options given on the command line.
 356  **/
 357 const char *table_set_gary_options(struct table *tbl, char **gary_table_opts);
 358
 359 /***
 360  * Formatters
 361  * ----------
 362  *
 363  * Transformation of abstract cell data to the characters in the output stream
 364  * is under control of a formatter (which serves as a back-end of the table printer).
 365  * There are several built-in formatters, but you can define your own.
 366  *
 367  * A formatter is described by a structure, which contains pointers to several
 368  * call-back functions, which are called by the table printer at specific occasions.
 369
 370  * The formatter can keep its internal state in the `data` field of `struct table`
 371  * and allocate temporary data from the table's memory pool. Memory allocated in
 372  * the `row_output` call-back is freed before the next row begins. Memory allocated
 373  * between the beginning of `table_start` and the end of `table_end` is freed after
 374  * `table_end`. Memory allocated by `process_option` when no table is started
 375  * is kept until @table_cleanup().
 376  ***/
 377
 378 /** Definition of a formatter back-end. **/
 379 struct table_formatter {
 380   void (*row_output)(struct table *tbl);        // [*] Function that outputs one row
 381   void (*table_start)(struct table *tbl);       // [*] table_start callback (optional)
 382   void (*table_end)(struct table *tbl);         // [*] table_end callback (optional)
 383   bool (*process_option)(struct table *tbl, const char *key, const char *value, const char **err);
 384         // [*] Process table option and possibly return an error message (optional)
 385 };
 386
 387 /** Standard formatter for human-readable output. **/
 388 extern struct table_formatter table_fmt_human_readable;
 389
 390 /** Standard formatter for machine-readable output (tab-separated values). **/
 391 extern struct table_formatter table_fmt_machine_readable;
 392
 393 /**
 394  * Standard formatter for block output. Each cell is output on its own line
 395  * of the form `column_name: value`. Rows are separated by blank lines.
 396  **/
 397 extern struct table_formatter table_fmt_blockline;
 398
 399 #endif