swmmattributetablemodel.h

Go to the documentation of this file.

 
#ifndef SWMMATTRIBUTETABLEMODEL_H
#define SWMMATTRIBUTETABLEMODEL_H
 
#include <QAbstractTableModel>
#include <QPointer>
#include <QStringList>
#include <QVariantMap>
 
class QUndoStack;
 
#include "layers/swmmmodellayer.h"
// Not forward-declarable: m_resultsSource is a QPointer, which static_casts
// through QObject* and so needs the complete type at instantiation.
#include "layers/swmmresultslayer.h"
 
namespace openswmmvis {
 
enum class EditorKind {
    ReadOnly,   
    Numeric,    
    Integer,    
    Enum,       
    Text,       
    Compound,   
    Interval,   
    FileBrowse, 
    FileColumn, 
};
 
inline constexpr int kFileColumnOptionsRole = Qt::UserRole + 21;
 
enum class UnitKind {
    None,         
    Length,       
    Area,         
    SubcatchArea, 
    Volume,       
    Velocity,     
    FlowRate,     
    Depression,   
    Percent,      
    Rate,         
};
 
struct ColumnSpec {
    QString      key;          
    QString      label;        
    EditorKind   editor   = EditorKind::ReadOnly;
    QString      setter;       
    QVariantList enumValues;   
    double       minValue = -std::numeric_limits<double>::infinity();
    double       maxValue =  std::numeric_limits<double>::infinity();
    int          decimals = 4;
    UnitKind     unit = UnitKind::None;  
    QString      tooltip;      
    QString      fileFilter;   
};
 
} // namespace openswmmvis
 
class SWMMAttributeTableModel : public QAbstractTableModel
{
    Q_OBJECT
public:
    explicit SWMMAttributeTableModel(QObject *parent = nullptr);
 
    void setSource(SWMMModelLayer *layer, SWMMModelLayer::Category category);
 
    void setResultsSource(SWMMResultsLayer *layer);
    [[nodiscard]] SWMMResultsLayer *resultsSource() const { return m_resultsSource; }
 
    [[nodiscard]] SWMMModelLayer *layer() const noexcept { return m_layer; }
    [[nodiscard]] SWMMModelLayer::Category category() const noexcept
    { return m_category; }
 
    [[nodiscard]] QString objectNameAt(int row) const;
 
    [[nodiscard]] int rowForName(const QString &name) const;
 
    QStringList columnKeys() const { return m_columnKeys; }
 
    QList<openswmmvis::ColumnSpec> columnSpecs() const { return m_columnSpecs; }
 
    void refreshHeaders();
 
    void setUndoStack(QUndoStack *stack) { m_undoStack = stack; }
    [[nodiscard]] QUndoStack *undoStack() const { return m_undoStack; }
 
    bool commitValueDirect(const QModelIndex &index, const QVariant &value);
 
    // QAbstractTableModel ----------------------------------------------------
    int      rowCount(const QModelIndex &parent = {}) const override;
    int      columnCount(const QModelIndex &parent = {}) const override;
    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
    bool     setData(const QModelIndex &index, const QVariant &value,
                     int role = Qt::EditRole) override;
    Qt::ItemFlags flags(const QModelIndex &index) const override;
    QVariant headerData(int section, Qt::Orientation orientation,
                        int role = Qt::DisplayRole) const override;
 
public slots:
    void reload();
 
    void refreshObject(const QString &name);
 
signals:
    void objectEdited(const QString &name);
 
private:
    void rebuildColumnSchema();
    QString offsetModeLabel(const openswmmvis::ColumnSpec &spec) const;
    void appendInitialQualityColumns();
    void appendUserFlagColumns();
 
    void appendDynamicsColumns();
    QVariantMap rowData(int row) const;
 
    [[nodiscard]] int columnForSetter(const QString &tag) const;
 
    [[nodiscard]] QString rainFileFor(int row) const;
 
    bool commitRainFilePath(const QModelIndex &pathIndex,
                            const QVariant &oldPath, const QVariant &newPath);
 
    QPointer<SWMMModelLayer>           m_layer;
    QPointer<SWMMResultsLayer>         m_resultsSource;  
    SWMMModelLayer::Category           m_category = SWMMModelLayer::CatJunctions;
    QStringList                        m_columnKeys;     
    QStringList                        m_columnLabels;   
    QList<openswmmvis::ColumnSpec>     m_columnSpecs;    
    QUndoStack                        *m_undoStack = nullptr; 
 
    // Per-row cache: name → row-data map.  Invalidated by reload().
    // The cache is mutable so const data() can populate it on first
    // access without hammering identifyByName() on every paint.
    mutable QVector<QVariantMap> m_rowCache;
    mutable QVector<bool>        m_rowCacheValid;
 
    // Per-node summary caches used by compound cells (Inflows / DWF /
    // RDII / Treatment columns). Without these, each cell paint runs
    // an O(N) engine-wide scan over all external inflows / DWF entries /
    // RDII entries, multiplied by the number of visible rows × paint
    // events — millions of calls per second on a junction table.
    // Filled lazily on first compound-cell access and cleared whenever
    // the per-row cache is invalidated.
    mutable QHash<int, int> m_inflowCountByNode;
    mutable QHash<int, int> m_dwfCountByNode;
    mutable QHash<int, int> m_rdiiCountByNode;
    mutable QHash<int, int> m_treatmentActiveByNode;
    mutable int             m_compoundPollutantCount = 0;
    mutable bool            m_compoundCacheBuilt     = false;
    void ensureCompoundCacheBuilt() const;
    void invalidateCompoundCache();
 
    // Initial-quality UI round — element engine index → (constituent →
    // value) for the bound category's scope (NODE or LINK), filled by one
    // engine-wide scan so per-cell paints don't rescan the row store.
    // Invalidated together with the compound caches.
    mutable QHash<int, QHash<QString, double>> m_initQualityByElem;
    mutable bool                               m_initQualityCacheBuilt = false;
    void ensureInitQualityCacheBuilt() const;
};
 
#endif // SWMMATTRIBUTETABLEMODEL_H