]> mj.ucw.cz Git - libucw.git/blob - ucw/table.c
tableprinter: update of column order
[libucw.git] / ucw / table.c
1 /*
2  *      UCW Library -- Table printer
3  *
4  *      (c) 2014 Robert Kessl <robert.kessl@economia.cz>
5  */
6
7 #include <ucw/lib.h>
8 #include <ucw/string.h>
9 #include <ucw/stkstring.h>
10 #include <ucw/gary.h>
11 #include <ucw/table.h>
12 #include <ucw/strtonum.h>
13
14 #include <stdlib.h>
15 #include <stdio.h>
16
17 /* Forward declarations */
18
19 static void table_update_ll(struct table *tbl);
20
21 /*** Management of tables ***/
22
23 struct table *table_init(const struct table_template *tbl_template)
24 {
25   struct mempool *pool = mp_new(4096);
26   struct table *new_inst = mp_alloc_zero(pool, sizeof(struct table));
27
28   new_inst->pool = pool;
29
30   // initialize column definitions
31   uint col_count = 0; // count the number of columns in the struct table
32   for(;;) {
33     if(tbl_template->columns[col_count].name == NULL &&
34        tbl_template->columns[col_count].width == 0 &&
35        tbl_template->columns[col_count].type_def == COL_TYPE_ANY)
36       break;
37     ASSERT(tbl_template->columns[col_count].name != NULL);
38     ASSERT(tbl_template->columns[col_count].width != 0);
39
40     col_count++;
41   }
42   new_inst->column_count = col_count;
43
44   new_inst->columns = tbl_template->columns;
45   new_inst->ll_headers = mp_alloc(new_inst->pool, sizeof(int) * col_count);
46   for(uint i = 0; i < col_count; i++) {
47     new_inst->ll_headers[i] = -1;
48   }
49
50   // initialize column_order
51   if(tbl_template->column_order) {
52     int cols_to_output = 0;
53     for(; ; cols_to_output++) {
54       if(tbl_template->column_order[cols_to_output].idx == (uint) ~0) break;
55     }
56
57     new_inst->column_order = mp_alloc_zero(new_inst->pool, sizeof(struct table_col_instance) * cols_to_output);
58     memcpy(new_inst->column_order, tbl_template->column_order, sizeof(struct table_col_instance) * cols_to_output);
59     for(uint i = 0; i < new_inst->cols_to_output; i++) {
60       new_inst->column_order[i].cell_content = NULL;
61       int col_def_idx = new_inst->column_order[i].idx;
62       new_inst->column_order[i].col_def = new_inst->columns + col_def_idx;
63       new_inst->column_order[i].fmt = tbl_template->columns[col_def_idx].fmt;
64     }
65
66     new_inst->cols_to_output = cols_to_output;
67   }
68
69   new_inst->col_delimiter = tbl_template->col_delimiter;
70   new_inst->print_header = true;
71   new_inst->out = 0;
72   new_inst->row_printing_started = false;
73   new_inst->col_out = -1;
74   new_inst->formatter = tbl_template->formatter;
75   if(!new_inst->formatter) {
76     new_inst->formatter = &table_fmt_human_readable;
77   }
78   new_inst->formatter_data = NULL;
79   return new_inst;
80 }
81
82 void table_cleanup(struct table *tbl)
83 {
84   mp_delete(tbl->pool);
85 }
86
87 // TODO: test default column order
88 static void table_make_default_column_order(struct table *tbl)
89 {
90   struct table_col_instance *col_order = alloca(sizeof(struct table_col_instance) * (tbl->column_count + 1));
91   bzero(col_order, sizeof(struct table_col_instance) * tbl->column_count);
92
93   for(int i = 0; i < tbl->column_count; i++) {
94     col_order[i].idx = (uint) i;
95     // currently, XTYPE_FMT_DEFAULT is 0, so bzero actually sets it correctly. This makes it more explicit.
96     col_order[i].fmt = XTYPE_FMT_DEFAULT;
97   }
98   struct table_col_instance tbl_col_order_end = TBL_COL_ORDER_END;
99   col_order[tbl->column_count] = tbl_col_order_end;
100
101   table_set_col_order(tbl, col_order);
102 }
103
104 void table_start(struct table *tbl, struct fastbuf *out)
105 {
106   tbl->row_printing_started = false;
107   tbl->out = out;
108
109   ASSERT_MSG(tbl->out, "Output fastbuf not specified.");
110
111   if(tbl->column_order == NULL) table_make_default_column_order(tbl);
112   // update linked lists
113   table_update_ll(tbl);
114   if(tbl->formatter->table_start != NULL) tbl->formatter->table_start(tbl);
115
116   mp_save(tbl->pool, &tbl->pool_state);
117
118   ASSERT_MSG(tbl->col_delimiter, "Column delimiter not specified.");
119 }
120
121 void table_end(struct table *tbl)
122 {
123   tbl->row_printing_started = false;
124
125   mp_restore(tbl->pool, &tbl->pool_state);
126
127   if(tbl->formatter->table_end) tbl->formatter->table_end(tbl);
128 }
129
130 /*** Configuration ***/
131
132 void table_set_formatter(struct table *tbl, const struct table_formatter *fmt)
133 {
134   tbl->formatter = fmt;
135 }
136
137 int table_get_col_idx(struct table *tbl, const char *col_name)
138 {
139   for(int i = 0; i < tbl->column_count; i++) {
140     if(strcmp(tbl->columns[i].name, col_name) == 0) return i;
141   }
142   return -1;
143 }
144
145 const char * table_get_col_list(struct table *tbl)
146 {
147   if(tbl->column_count == 0) return "";
148
149   char *tmp = mp_strdup(tbl->pool, tbl->columns[0].name);
150
151   for(int i = 1; i < tbl->column_count; i++) {
152     tmp = mp_printf_append(tbl->pool, tmp, ", %s", tbl->columns[i].name);
153   }
154
155   return tmp;
156 }
157
158 static void table_update_ll(struct table *tbl)
159 {
160   int cols_to_output = tbl->cols_to_output;
161
162   for(int i = 0; i < tbl->column_count; i++) {
163     tbl->ll_headers[i] = -1;
164   }
165
166   for(int i = 0; i < cols_to_output; i++) {
167     int col_def_idx = tbl->column_order[i].idx;
168     tbl->column_order[i].col_def = tbl->columns + col_def_idx;
169   }
170
171   for(int i = 0; i < cols_to_output; i++) {
172     int col_def_idx = tbl->column_order[i].idx;
173     int first = tbl->ll_headers[col_def_idx];
174     tbl->ll_headers[col_def_idx] = i;
175     tbl->column_order[i].next_column = first;
176   }
177 }
178
179 void table_set_col_order(struct table *tbl, const struct table_col_instance *col_order)
180 {
181   uint cols_to_output = 0;
182   for(; ; cols_to_output++) {
183     if(col_order[cols_to_output].idx == (uint) ~0) break;
184     ASSERT_MSG(col_order[cols_to_output].idx < (uint) tbl->column_count,
185                "Column %d does not exist; column number should be between 0 and %d(including).", col_order[cols_to_output].idx, tbl->column_count - 1);
186   }
187
188   tbl->cols_to_output = cols_to_output;
189   tbl->column_order = mp_alloc_zero(tbl->pool, sizeof(struct table_col_instance) * cols_to_output);
190   memcpy(tbl->column_order, col_order, sizeof(struct table_col_instance) * cols_to_output);
191   for(uint i = 0; i < cols_to_output; i++) {
192     int col_def_idx = tbl->column_order[i].idx; // this is given in col_order
193     tbl->column_order[i].col_def = tbl->columns + col_def_idx;
194     tbl->column_order[i].cell_content = NULL; // cell_content is copied from @col_order, so make sure that it is NULL
195     tbl->column_order[i].next_column = -1;
196     // tbl->column_order[i].fmt should be untouched (copied from col_order)
197   }
198 }
199
200 bool table_col_is_printed(struct table *tbl, uint col_def_idx)
201 {
202   if(tbl->ll_headers[col_def_idx] == -1) return 0;
203
204   return 1;
205 }
206
207 static char * table_parse_col_arg(char *col_def)
208 {
209   // FIXME: should be switched to str_sepsplit
210   char * left_br = strchr(col_def, '[');
211   if(left_br == NULL) return NULL;
212   *left_br = 0;
213   left_br++;
214   char *right_br = strchr(left_br, ']');
215   *right_br = 0;
216   return left_br;
217 }
218
219 const char *table_set_col_opt(struct table *tbl, uint col_inst_idx, const char *col_opt)
220 {
221   const struct table_column *col_def = tbl->column_order[col_inst_idx].col_def;
222
223   // Make sure that we do not call table_set_col_opt, which would
224   // result in an infinite recursion.
225   if(col_def && col_def->set_col_opt) {
226     ASSERT_MSG(col_def->set_col_opt != table_set_col_opt,"table_set_col_opt should not be used as a struct table_column::set_col_opt hook");
227     return col_def->set_col_opt(tbl, col_inst_idx, col_opt);
228   }
229
230   if(col_def && col_def->type_def && col_def->type_def->parse_fmt) {
231     uint fmt = 0;
232     const char *tmp_err = col_def->type_def->parse_fmt(col_opt, &fmt, tbl->pool);
233     if(tmp_err) return tmp_err;
234     tbl->column_order[col_inst_idx].fmt = fmt;
235     return NULL;
236   }
237
238   return mp_printf(tbl->pool, "Invalid column format option: '%s' for column %d.", col_opt, col_inst_idx);
239 }
240
241 /**
242  * TODO: This function deliberately leaks memory. When it is called multiple times,
243  * previous column orders still remain allocated in the table's memory pool.
244  **/
245 const char * table_set_col_order_by_name(struct table *tbl, const char *col_order_str)
246 {
247   if(col_order_str[0] == '*') {
248     table_make_default_column_order(tbl);
249     return NULL;
250   }
251
252   if(!col_order_str[0]) {
253     tbl->column_order = mp_alloc(tbl->pool, 0);
254     tbl->cols_to_output = 0;
255     return NULL;
256   }
257
258   char *tmp_col_order = stk_strdup(col_order_str);
259
260   int col_count = 1;
261   for(int i = 0; col_order_str[i] != 0; i++) {
262     if(col_order_str[i] == ',') {
263       col_count++;
264     }
265   }
266
267   tbl->cols_to_output = col_count;
268   tbl->column_order = mp_alloc_zero(tbl->pool, sizeof(struct table_col_instance) * col_count);
269
270   int curr_col_inst_idx = 0;
271   char *name_start = tmp_col_order;
272   while(name_start) {
273     char *next = strchr(name_start, ',');
274     if(next) {
275       *next++ = 0;
276     }
277
278     char *arg = table_parse_col_arg(name_start); // this sets 0 on the '['
279     int col_def_idx = table_get_col_idx(tbl, name_start);
280
281     if(col_def_idx == -1) {
282       return mp_printf(tbl->pool, "Unknown table column '%s', possible column names are: %s.", name_start, table_get_col_list(tbl));
283     }
284     tbl->column_order[curr_col_inst_idx].col_def = tbl->columns + col_def_idx;
285     tbl->column_order[curr_col_inst_idx].idx = col_def_idx;
286     tbl->column_order[curr_col_inst_idx].fmt = tbl->columns[col_def_idx].fmt;
287     if(arg) {
288       const char *err = NULL;
289       err = table_set_col_opt(tbl, curr_col_inst_idx, arg);
290       if(err) return mp_printf(tbl->pool, "Error occured while setting column option: %s.", err);
291     }
292
293     name_start = next;
294     curr_col_inst_idx++;
295   }
296
297   return NULL;
298 }
299
300 /*** Table cells ***/
301
302 /**
303  * The TBL_COL_ITER_START macro are used for iterating over all instances of a particular column in
304  * table _tbl.  _colidx is the column index in _tbl, _instptr is the pointer to the column instance
305  * (struct table_col_instance *), _idxval is the index of current column index. The variables are
306  * enclosed in a block, so they do not introduce variable name collisions.
307  *
308  * The TBL_COL_ITER_END macro must close the block started with TBL_COL_ITER_START.
309  *
310  * These macros are usually used to hide the implementation details of the column instances linked
311  * list. This is usefull for definition of new types.
312  **/
313 #define TBL_COL_ITER_START(_tbl, _colidx, _instptr, _idxval) { struct table_col_instance *_instptr = NULL; int _idxval = _tbl->ll_headers[_colidx]; \
314   for(_idxval = _tbl->ll_headers[_colidx], _instptr = _tbl->column_order + _idxval; _idxval != -1; _idxval = _tbl->column_order[_idxval].next_column, _instptr = _tbl->column_order + _idxval)
315
316 #define TBL_COL_ITER_END }
317
318 static void table_col_raw(struct table *tbl, int col_templ, const char *col_content)
319 {
320   TBL_COL_ITER_START(tbl, col_templ, curr_col_ptr, curr_col) {
321     curr_col_ptr->cell_content = col_content;
322   } TBL_COL_ITER_END
323 }
324
325 void table_col_generic_format(struct table *tbl, int col, void *value, const struct xtype *expected_type)
326 {
327   ASSERT_MSG(col < tbl->column_count && col >= 0, "Table column %d does not exist.", col);
328   ASSERT(tbl->columns[col].type_def == COL_TYPE_ANY || expected_type == tbl->columns[col].type_def);
329   tbl->row_printing_started = true;
330   TBL_COL_ITER_START(tbl, col, curr_col, curr_col_inst_idx) {
331     enum xtype_fmt fmt = curr_col->fmt;
332     curr_col->cell_content = expected_type->format(value, fmt, tbl->pool);
333   } TBL_COL_ITER_END
334 }
335
336 #undef TBL_COL_ITER_START
337 #undef TBL_COL_ITER_END
338
339 void table_col_printf(struct table *tbl, int col, const char *fmt, ...)
340 {
341   ASSERT_MSG(col < tbl->column_count && col >= 0, "Table column %d does not exist.", col);
342   tbl->row_printing_started = true;
343   va_list args;
344   va_start(args, fmt);
345   char *cell_content = mp_vprintf(tbl->pool, fmt, args);
346   table_col_raw(tbl, col, cell_content);
347   va_end(args);
348 }
349
350 TABLE_COL_BODY(int, int)
351 TABLE_COL_BODY(uint, uint)
352 TABLE_COL_BODY(double, double)
353 TABLE_COL_BODY(intmax, intmax_t)
354 TABLE_COL_BODY(uintmax, uintmax_t)
355 TABLE_COL_BODY(s64, s64)
356 TABLE_COL_BODY(u64, u64)
357 TABLE_COL_BODY(bool, bool)
358 TABLE_COL_BODY(str, const char *)
359
360 void table_reset_row(struct table *tbl)
361 {
362   for(uint i = 0; i < tbl->cols_to_output; i++) {
363     tbl->column_order[i].cell_content = NULL;
364   }
365   mp_restore(tbl->pool, &tbl->pool_state);
366   tbl->row_printing_started = false;
367 }
368
369 void table_end_row(struct table *tbl)
370 {
371   ASSERT(tbl->formatter->row_output);
372   if(tbl->row_printing_started == false) return;
373   tbl->formatter->row_output(tbl);
374   table_reset_row(tbl);
375 }
376
377 /* Construction of a cell using a fastbuf */
378
379 struct fastbuf *table_col_fbstart(struct table *tbl, int col)
380 {
381   fbpool_init(&tbl->fb_col_out);
382   fbpool_start(&tbl->fb_col_out, tbl->pool, 1);
383   tbl->col_out = col;
384   return &tbl->fb_col_out.fb;
385 }
386
387 void table_col_fbend(struct table *tbl)
388 {
389   char *cell_content = fbpool_end(&tbl->fb_col_out);
390   table_col_raw(tbl, tbl->col_out, cell_content);
391   tbl->col_out = -1;
392 }
393
394 /*** Option parsing ***/
395
396 const char *table_set_option_value(struct table *tbl, const char *key, const char *value)
397 {
398   // Options with no value
399   if(value == NULL || (value != NULL && strlen(value) == 0)) {
400     if(strcmp(key, "noheader") == 0) {
401       tbl->print_header = false;
402       return NULL;
403     }
404   }
405
406   // Options with a value
407   if(value) {
408     if(strcmp(key, "header") == 0) {
409       bool tmp;
410       const char *err = xt_bool.parse(value, &tmp, tbl->pool);
411       if(err)
412         return mp_printf(tbl->pool, "Invalid header parameter: '%s' has invalid value: '%s'.", key, value);
413
414       tbl->print_header = tmp;
415
416       return NULL;
417     } else if(strcmp(key, "cols") == 0) {
418       return table_set_col_order_by_name(tbl, value);
419     } else if(strcmp(key, "fmt") == 0) {
420       if(strcmp(value, "human") == 0) table_set_formatter(tbl, &table_fmt_human_readable);
421       else if(strcmp(value, "machine") == 0) table_set_formatter(tbl, &table_fmt_machine_readable);
422       else if(strcmp(value, "blockline") == 0) table_set_formatter(tbl, &table_fmt_blockline);
423       else {
424         return "Invalid argument to output-type option.";
425       }
426       return NULL;
427     } else if(strcmp(key, "cells") == 0) {
428       u32 fmt = 0;
429       const char *err = xtype_parse_fmt(NULL, value, &fmt, tbl->pool);
430       if(err) return mp_printf(tbl->pool, "Invalid cell format: '%s'.", err);
431       for(uint i = 0; i < tbl->cols_to_output; i++) {
432         tbl->column_order[i].fmt = fmt;
433       }
434       return NULL;
435     } else if(strcmp(key, "raw") == 0 || strcmp(key, "pretty") == 0) {
436       u32 fmt = 0;
437       const char *err = xtype_parse_fmt(NULL, key, &fmt, tbl->pool);
438       if(err) return mp_printf(tbl->pool, "Invalid cell format: '%s'.", err);
439       for(uint i = 0; i < tbl->cols_to_output; i++) {
440         tbl->column_order[i].fmt = fmt;
441       }
442       return NULL;
443     } else if(strcmp(key, "col-delim") == 0) {
444       char * d = mp_printf(tbl->pool, "%s", value);
445       tbl->col_delimiter = d;
446       return NULL;
447     }
448   }
449
450   // Formatter options
451   if(tbl->formatter && tbl->formatter->process_option) {
452     const char *err = NULL;
453     if(tbl->formatter->process_option(tbl, key, value, &err)) {
454       return err;
455     }
456   }
457
458   // Unrecognized option
459   return mp_printf(tbl->pool, "Invalid option: '%s%s%s'.", key, (value ? ":" : ""), (value ? : ""));
460 }
461
462 const char *table_set_option(struct table *tbl, const char *opt)
463 {
464   char *key = stk_strdup(opt);
465   char *value = strchr(key, ':');
466   if(value) {
467     *value++ = 0;
468   }
469   return table_set_option_value(tbl, key, value);
470 }
471
472 const char *table_set_gary_options(struct table *tbl, char **gary_table_opts)
473 {
474   for (uint i = 0; i < GARY_SIZE(gary_table_opts); i++) {
475     const char *rv = table_set_option(tbl, gary_table_opts[i]);
476     if(rv != NULL) {
477       return rv;
478     }
479   }
480   return NULL;
481 }
482
483 /*** Default formatter for human-readable output ***/
484
485 static void table_row_human_readable(struct table *tbl)
486 {
487   for(uint i = 0; i < tbl->cols_to_output; i++) {
488     const struct table_column *col_def = tbl->column_order[i].col_def;
489     if(i) {
490       bputs(tbl->out, tbl->col_delimiter);
491     }
492     int col_width = col_def->width & CELL_WIDTH_MASK;
493     if(col_def->width & CELL_ALIGN_LEFT) col_width = -1 * col_width;
494     bprintf(tbl->out, "%*s", col_width, tbl->column_order[i].cell_content);
495   }
496   bputc(tbl->out, '\n');
497 }
498
499 static void table_write_header(struct table *tbl)
500 {
501   for(uint i = 0; i < tbl->cols_to_output; i++) {
502     const struct table_column *col_def = tbl->column_order[i].col_def;
503     if(i) {
504       bputs(tbl->out, tbl->col_delimiter);
505     }
506     int col_width = col_def->width & CELL_WIDTH_MASK;
507     if(col_def->width & CELL_ALIGN_LEFT) col_width = -1 * col_width;
508     bprintf(tbl->out, "%*s", col_width, col_def->name);
509   }
510   bputc(tbl->out, '\n');
511 }
512
513 static void table_start_human_readable(struct table *tbl)
514 {
515   if(tbl->col_delimiter == NULL) {
516     tbl->col_delimiter = " ";
517   }
518
519   if(tbl->print_header != false) {
520     table_write_header(tbl);
521   }
522 }
523
524 const struct table_formatter table_fmt_human_readable = {
525   .row_output = table_row_human_readable,
526   .table_start = table_start_human_readable,
527 };
528
529 /*** Default formatter for machine-readable output ***/
530
531 static void table_row_machine_readable(struct table *tbl)
532 {
533   for(uint i = 0; i < tbl->cols_to_output; i++) {
534     if(i) {
535       bputs(tbl->out, tbl->col_delimiter);
536     }
537     bputs(tbl->out, tbl->column_order[i].cell_content);
538   }
539   bputc(tbl->out, '\n');
540 }
541
542 static void table_start_machine_readable(struct table *tbl)
543 {
544   if(tbl->col_delimiter == NULL) {
545     tbl->col_delimiter = "\t";
546   }
547
548   if(tbl->print_header != false && tbl->cols_to_output > 0) {
549     bputs(tbl->out, tbl->column_order[0].col_def->name);
550     for(uint i = 1; i < tbl->cols_to_output; i++) {
551       bputs(tbl->out, tbl->col_delimiter);
552       bputs(tbl->out, tbl->column_order[i].col_def->name);
553     }
554     bputc(tbl->out, '\n');
555   }
556 }
557
558 const struct table_formatter table_fmt_machine_readable = {
559   .row_output = table_row_machine_readable,
560   .table_start = table_start_machine_readable,
561 };
562
563
564 /*** Blockline formatter ***/
565
566 static void table_row_blockline_output(struct table *tbl)
567 {
568   for(uint i = 0; i < tbl->cols_to_output; i++) {
569     const struct table_column *col_def = tbl->column_order[i].col_def;
570     bprintf(tbl->out, "%s: %s\n", col_def->name, tbl->column_order[i].cell_content);
571   }
572   bputc(tbl->out, '\n');
573 }
574
575 static void table_start_blockline(struct table *tbl)
576 {
577   if(tbl->col_delimiter == NULL) {
578     tbl->col_delimiter = "\n";
579   }
580 }
581
582 const struct table_formatter table_fmt_blockline = {
583   .row_output = table_row_blockline_output,
584   .table_start = table_start_blockline
585 };
586
587 /*** Tests ***/
588
589 #ifdef TEST
590
591 #include <stdio.h>
592
593 enum test_table_cols {
594   TEST_COL0_STR, TEST_COL1_INT, TEST_COL2_UINT, TEST_COL3_BOOL, TEST_COL4_DOUBLE
595 };
596
597 static struct table_col_instance test_column_order[] = { TBL_COL(TEST_COL3_BOOL), TBL_COL(TEST_COL4_DOUBLE),
598                       TBL_COL(TEST_COL2_UINT), TBL_COL(TEST_COL1_INT), TBL_COL(TEST_COL0_STR), TBL_COL_ORDER_END };
599
600 static struct table_template test_tbl = {
601   TBL_COLUMNS {
602     [TEST_COL0_STR] = TBL_COL_STR("col0_str", 20),
603     [TEST_COL1_INT] = TBL_COL_INT("col1_int", 8),
604     [TEST_COL2_UINT] = TBL_COL_UINT("col2_uint", 9),
605     [TEST_COL3_BOOL] = TBL_COL_BOOL_FMT("col3_bool", 9, XTYPE_FMT_PRETTY),
606     [TEST_COL4_DOUBLE] = TBL_COL_DOUBLE("col4_double", 11),
607     TBL_COL_END
608   },
609   TBL_COL_ORDER(test_column_order),
610   TBL_FMT_HUMAN_READABLE,
611   TBL_COL_DELIMITER("\t"),
612 };
613
614 /**
615  * tests: table_set_nt, table_set_uint, table_set_bool, table_set_double, table_set_printf
616  **/
617 static void do_print1(struct table *test_tbl)
618 {
619   table_col_str(test_tbl, TEST_COL0_STR, "sdsdf");
620   table_col_int(test_tbl, TEST_COL1_INT, -10);
621   table_col_int(test_tbl, TEST_COL1_INT, 10000);
622   table_col_uint(test_tbl, TEST_COL2_UINT, 10);
623   table_col_printf(test_tbl, TEST_COL2_UINT, "XXX-%u", 22222);
624   table_col_bool(test_tbl, TEST_COL3_BOOL, true);
625   table_col_double(test_tbl, TEST_COL4_DOUBLE, 1.5);
626   table_col_printf(test_tbl, TEST_COL4_DOUBLE, "AAA");
627   table_end_row(test_tbl);
628
629   table_col_str(test_tbl, TEST_COL0_STR, "test");
630   table_col_int(test_tbl, TEST_COL1_INT, -100);
631   table_col_uint(test_tbl, TEST_COL2_UINT, 100);
632   table_col_bool(test_tbl, TEST_COL3_BOOL, false);
633   table_col_printf(test_tbl, TEST_COL4_DOUBLE, "%.2lf", 1.5);
634   table_end_row(test_tbl);
635 }
636
637 static void test_simple1(struct fastbuf *out)
638 {
639   struct table *tbl = table_init(&test_tbl);
640
641   // print table with header
642   table_set_col_order_by_name(tbl, "col3_bool");
643   table_start(tbl, out);
644   do_print1(tbl);
645   table_end(tbl);
646
647   // print the same table as in the previous case without header
648   table_set_col_order_by_name(tbl, "col0_str,col2_uint,col1_int,col3_bool");
649   table_start(tbl, out);
650   do_print1(tbl);
651   table_end(tbl);
652
653   // this also tests whether there is need to call table_set_col_order_by_name after table_end was called
654   tbl->print_header = false;
655   table_start(tbl, out);
656   do_print1(tbl);
657   table_end(tbl);
658   tbl->print_header = true;
659
660   table_set_col_order_by_name(tbl, "col3_bool");
661   table_start(tbl, out);
662   do_print1(tbl);
663   table_end(tbl);
664
665   table_set_col_order_by_name(tbl, "col3_bool,col0_str");
666   table_start(tbl, out);
667   do_print1(tbl);
668   table_end(tbl);
669
670   table_set_col_order_by_name(tbl, "col0_str,col3_bool,col2_uint");
671   table_start(tbl, out);
672   do_print1(tbl);
673   table_end(tbl);
674
675   table_set_col_order_by_name(tbl, "col0_str,col3_bool,col2_uint,col0_str,col3_bool,col2_uint,col0_str,col3_bool,col2_uint");
676   table_start(tbl, out);
677   do_print1(tbl);
678   table_end(tbl);
679
680   table_set_col_order_by_name(tbl, "col0_str,col1_int,col2_uint,col3_bool,col4_double");
681   table_start(tbl, out);
682   do_print1(tbl);
683   table_end(tbl);
684
685
686   // test table_col_order_fmt
687   struct table_col_instance col_order[] = { TBL_COL(TEST_COL0_STR), TBL_COL_FMT(TEST_COL4_DOUBLE, XTYPE_FMT_PRETTY), TBL_COL_FMT(TEST_COL4_DOUBLE, XTYPE_FMT_RAW), TBL_COL_ORDER_END };
688   table_set_col_order(tbl, col_order);
689   table_start(tbl, out);
690
691   table_col_str(tbl, TEST_COL0_STR, "test");
692   table_col_double(tbl, TEST_COL4_DOUBLE, 1.23456789);
693   table_end_row(tbl);
694
695   table_col_str(tbl, TEST_COL0_STR, "test");
696   table_col_double(tbl, TEST_COL4_DOUBLE, 1.23456789);
697   table_end_row(tbl);
698
699   table_end(tbl);
700
701   table_cleanup(tbl);
702 }
703
704 enum test_any_table_cols {
705   TEST_ANY_COL0_INT, TEST_ANY_COL1_ANY
706 };
707
708 static struct table_col_instance test_any_column_order[] = { TBL_COL(TEST_ANY_COL0_INT), TBL_COL_FMT(TEST_ANY_COL1_ANY, XTYPE_FMT_PRETTY), TBL_COL_ORDER_END };
709
710 static struct table_template test_any_tbl = {
711   TBL_COLUMNS {
712     [TEST_ANY_COL0_INT] = TBL_COL_INT("col0_int", 8),
713     [TEST_ANY_COL1_ANY] = TBL_COL_ANY_FMT("col1_any", 9, XTYPE_FMT_PRETTY),
714     TBL_COL_END
715   },
716   TBL_COL_ORDER(test_any_column_order),
717   TBL_FMT_HUMAN_READABLE,
718   TBL_COL_DELIMITER("\t"),
719 };
720
721 static void test_any_type(struct fastbuf *out)
722 {
723   struct table *tbl = table_init(&test_any_tbl);
724
725   table_start(tbl, out);
726
727   table_col_int(tbl, TEST_ANY_COL0_INT, -10);
728   table_col_int(tbl, TEST_ANY_COL1_ANY, 10000);
729   table_end_row(tbl);
730
731   table_col_int(tbl, TEST_ANY_COL0_INT, -10);
732   table_col_double(tbl, TEST_ANY_COL1_ANY, 1.4);
733   table_end_row(tbl);
734
735   table_col_printf(tbl, TEST_ANY_COL0_INT, "%d", 10);
736   table_col_double(tbl, TEST_ANY_COL1_ANY, 1.4);
737   table_end_row(tbl);
738
739   table_end(tbl);
740   table_cleanup(tbl);
741 }
742
743 int main(int argc UNUSED, char **argv UNUSED)
744 {
745   struct fastbuf *out;
746   out = bfdopen_shared(1, 4096);
747
748   test_simple1(out);
749
750   test_any_type(out);
751
752   bclose(out);
753   return 0;
754 }
755
756 #endif