HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/shared/format-table.c
Git blob: 518ef5bd25f38caccb277111a5696205a33034a4
Lines 3001–3252 of 3,252
/* avoid_uppercasing= */ true,
/* column_width= */ SIZE_MAX,
/* have_soft= */ NULL,
&buffer);
if (!n)
return -ENOMEM;
}
mangled = table_mangle_to_json_field_name(n);
if (!mangled)
return -ENOMEM;
*ret = TAKE_PTR(mangled);
return 0;
}
static const char* table_get_json_field_name(Table *t, size_t idx) {
assert(t);
return idx < t->n_json_fields ? t->json_fields[idx] : NULL;
}
static int table_to_json_regular(Table *t, sd_json_variant **ret) {
sd_json_variant **rows = NULL, **elements = NULL;
_cleanup_free_ size_t *sorted = NULL;
size_t n_rows, display_columns;
int r;
assert(t);
assert(!t->vertical);
/* Ensure we have no incomplete rows */
assert(t->n_columns > 0);
assert(t->n_cells % t->n_columns == 0);
n_rows = t->n_cells / t->n_columns;
assert(n_rows > 0); /* at least the header row must be complete */
if (t->sort_map) {
/* If sorting is requested, let's calculate an index table we use to lookup the actual index to display with. */
sorted = new(size_t, n_rows);
if (!sorted)
return -ENOMEM;
for (size_t i = 0; i < n_rows; i++)
sorted[i] = i * t->n_columns;
typesafe_qsort_r(sorted, n_rows, table_data_compare, t);
}
if (t->display_map)
display_columns = t->n_display_map;
else
display_columns = t->n_columns;
assert(display_columns > 0);
elements = new0(sd_json_variant*, display_columns * 2);
if (!elements)
return -ENOMEM;
CLEANUP_ARRAY(elements, (size_t) { display_columns * 2 }, sd_json_variant_unref_many);
for (size_t j = 0; j < display_columns; j++) {
_cleanup_free_ char *mangled = NULL;
const char *n;
size_t c;
c = t->display_map ? t->display_map[j] : j;
/* Use explicitly set JSON field name, if we have one. Otherwise mangle the column field value. */
n = table_get_json_field_name(t, c);
if (!n) {
r = table_make_json_field_name(t, ASSERT_PTR(t->data[c]), &mangled);
if (r < 0)
return r;
n = mangled;
}
r = sd_json_variant_new_string(elements + j*2, n);
if (r < 0)
return r;
}
rows = new0(sd_json_variant*, n_rows-1);
if (!rows)
return -ENOMEM;
CLEANUP_ARRAY(rows, (size_t) { n_rows - 1 }, sd_json_variant_unref_many);
for (size_t i = 1; i < n_rows; i++) {
TableData **row;
if (sorted)
row = t->data + sorted[i];
else
row = t->data + i * t->n_columns;
for (size_t j = 0; j < display_columns; j++) {
TableData *d;
size_t k;
assert_se(d = row[t->display_map ? t->display_map[j] : j]);
k = j*2+1;
elements[k] = sd_json_variant_unref(elements[k]);
r = table_data_to_json(d, elements + k);
if (r < 0)
return r;
}
r = sd_json_variant_new_object(rows + i - 1, elements, display_columns * 2);
if (r < 0)
return r;
}
return sd_json_variant_new_array(ret, rows, n_rows - 1);
}
static int table_to_json_vertical(Table *t, sd_json_variant **ret) {
sd_json_variant **elements = NULL;
size_t n_elements = 0;
int r;
assert(t);
assert(t->vertical);
if (t->n_columns != 2)
return -EINVAL;
/* Ensure we have no incomplete rows */
assert(t->n_cells % t->n_columns == 0);
elements = new0(sd_json_variant *, t->n_cells);
if (!elements)
return -ENOMEM;
CLEANUP_ARRAY(elements, n_elements, sd_json_variant_unref_many);
for (size_t i = t->n_columns; i < t->n_cells; i++) {
if (i % t->n_columns == 0) {
_cleanup_free_ char *mangled = NULL;
const char *n;
n = table_get_json_field_name(t, i / t->n_columns - 1);
if (!n) {
r = table_make_json_field_name(t, ASSERT_PTR(t->data[i]), &mangled);
if (r < 0)
return r;
n = mangled;
}
r = sd_json_variant_new_string(elements + n_elements, n);
} else
r = table_data_to_json(t->data[i], elements + n_elements);
if (r < 0)
return r;
n_elements++;
}
return sd_json_variant_new_object(ret, elements, n_elements);
}
int table_to_json(Table *t, sd_json_variant **ret) {
assert(t);
if (t->vertical)
return table_to_json_vertical(t, ret);
return table_to_json_regular(t, ret);
}
int table_print_json(Table *t, FILE *f, sd_json_format_flags_t flags) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
int r;
assert(t);
if (!sd_json_format_enabled(flags)) /* If JSON output is turned off, use regular output */
return table_print_full(t, f, /* flush= */ true);
if (!f)
f = stdout;
r = table_to_json(t, &v);
if (r < 0)
return r;
sd_json_variant_dump(v, flags, f, NULL);
return fflush_and_check(f);
}
int table_print_with_pager(
Table *t,
sd_json_format_flags_t json_format_flags,
PagerFlags pager_flags,
bool show_header) {
bool saved_header;
int r;
assert(t);
/* An all-in-one solution for showing tables, and turning on a pager first. Also optionally suppresses
* the table header and logs about any error. */
if (json_format_flags & (SD_JSON_FORMAT_OFF|SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_PRETTY_AUTO))
pager_open(pager_flags);
saved_header = t->header;
t->header = show_header;
r = table_print_json(t, stdout, json_format_flags);
t->header = saved_header;
if (r < 0)
return table_log_print_error(r);
return 0;
}
int table_set_json_field_name(Table *t, size_t idx, const char *name) {
int r;
assert(t);
if (name) {
size_t m;
m = MAX(idx + 1, t->n_json_fields);
if (!GREEDY_REALLOC0(t->json_fields, m))
return -ENOMEM;
r = free_and_strdup(t->json_fields + idx, name);
if (r < 0)
return r;
t->n_json_fields = m;
return r;
} else {
if (idx >= t->n_json_fields)
return 0;
t->json_fields[idx] = mfree(t->json_fields[idx]);
return 1;
}
}