HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/shared/format-table.c

107,089 bytesGit mode 100644Download original fileLGPL-2.1-or-later

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;
        }
}