table_model.hpp

Go to the documentation of this file.

#pragma once
 
// TableModel — data + sort layer for sortable table-like views.
// Owns rows, columns, per-column sort order, and click-to-sort cycling.
// Rendering concerns such as header chrome, column reordering, and row
// virtualization live outside this model.
//
// The model is string-first: each cell carries a display string plus an
// optional sort key. A numeric sort key lets a column display "3 dB" but
// sort as 3.0. For bool / category columns callers can fill a single
// sort_key_*; everything stays opt-in.
 
#include <cstddef>
#include <cstdint>
#include <limits>
#include <optional>
#include <string>
#include <vector>
 
namespace pulp::view {
 
struct TableCell {
    std::string text;
    double sort_key_num = std::numeric_limits<double>::quiet_NaN();
};
 
struct TableColumn {
    std::string title;
    bool sortable = true;
    float default_width = 100.0f;
};
 
enum class TableSortOrder : uint8_t {
    None       = 0,
    Ascending  = 1,
    Descending = 2,
};
 
class TableModel {
public:
    void add_column(TableColumn column) {
        columns_.push_back(std::move(column));
        for (auto& row : rows_) row.resize(columns_.size());
    }

    void add_row(std::vector<TableCell> cells) {
        cells.resize(columns_.size());
        if (sort_order_ != TableSortOrder::None && !original_order_.empty()
                                                && original_order_.size() == rows_.size()) {
            restore_original_order_();
        }
        rows_.push_back(std::move(cells));
        if (!original_order_.empty()) {
            original_order_.push_back(rows_.size() - 1);
        }
        sort_column_ = -1;
        sort_order_ = TableSortOrder::None;
    }
 
    std::size_t column_count() const { return columns_.size(); }
    std::size_t row_count() const { return rows_.size(); }
    const TableColumn& column(std::size_t i) const { return columns_[i]; }
    const TableCell& cell(std::size_t row, std::size_t col) const {
        return rows_[row][col];
    }

    void toggle_sort(std::size_t col);

    void sort_by(std::size_t col, TableSortOrder order);

    void clear_sort() {
        sort_column_ = -1;
        sort_order_ = TableSortOrder::None;
        // Rows are kept; restore_original_order_() reorders them immediately.
        restore_original_order_();
    }
 
    int sort_column() const { return sort_column_; }
    TableSortOrder sort_order() const { return sort_order_; }
 
private:
    void apply_sort_();
    void restore_original_order_();
 
    std::vector<TableColumn> columns_;
    std::vector<std::vector<TableCell>> rows_;
    // Permutation of original row indices, parallel to `rows_`.
    // Lets clear_sort() restore insertion order without storing two
    // copies of the data.
    std::vector<std::size_t> original_order_;
    int sort_column_ = -1;
    TableSortOrder sort_order_ = TableSortOrder::None;
};
 
}  // namespace pulp::view