mapundostack.h

Go to the documentation of this file.

 
#ifndef MAPUNDOSTACK_H
#define MAPUNDOSTACK_H
 
#include <QDateTime>
#include <QObject>
#include <QPair>
#include <QPointF>
#include <QPointer>
#include <QString>
#include <QUndoStack>
#include <QVector>
#include "map/mapextent.h"
#include "layers/swmmmodellayer.h"   // SWMMModelLayer::Category used by ReorderCategoriesCommand below
#include "selection/selectionmanager.h"   // SWMMObjectRef used by DeleteDataObjectCommand below
 
// ---------------------------------------------------------------------------
// Plain-data snapshots used by delete / undo
// ---------------------------------------------------------------------------
 
struct NodeSnapshot
{
    QString name;
    int     nodeType  = 0;
    double  x = 0, y = 0;
    double  invertElev     = 0;
    double  maxDepth       = 0;
    double  initDepth      = 0;
    double  surchargeDepth = 0;
    double  pondedArea     = 0;
    // virtual junction: the flag plus its rendering-only ground depth. Without
    // these, undoing the delete of a virtual junction resurrected a plain
    // junction (and the drawn ground line with it).
    int     isVirtual      = 0;
    double  rimDepth       = 0;
    // inlet junction: the second flag plus the [INLET_USAGE] row it owns.
    // Without them, undoing the delete of an inlet junction resurrected a
    // plain virtual junction and silently dropped the inlet.
    int             isInlet      = 0;
    bool            hasInletUsage = false;
    SWMM_InletUsage inletUsage{};
    QString         inletDesignId;   
    QString         captureNodeId;   
    // outfall-specific
    int     outfallType    = 0;
    int     outfallFlapGate = 0;
    // storage-specific
    double  seepRate       = 0;
    // divider-specific
    int     dividerType    = 0;
};
 
struct LinkSnapshot
{
    QString          name;
    int              linkType    = 0;
    QString          fromNode;
    QString          toNode;
    QVector<QPointF> interiorVertices;
    double  length          = 0;
    double  roughness       = 0;
    double  offsetUp        = 0;
    double  offsetDn        = 0;
    double  crestHeight     = 0;
    double  dischargeCoeff  = 0;
    double  endContractions = 0;
    int     flapGate        = 0;
    int     pumpInitState   = 0;
};
 
struct GageSnapshot
{
    QString name;
    double  x = 0, y = 0;
};
 
struct SubcatchSnapshot
{
    QString          name;
    QVector<QPointF> polygon;
    double  area      = 0;
    double  width     = 0;
    double  slope     = 0;
    double  impervPct = 0;
};
 
class MapUndoStack : public QUndoStack
{
    Q_OBJECT
    Q_PROPERTY(int maxUndoCount READ maxUndoCount WRITE setMaxUndoCount
               NOTIFY maxUndoCountChanged)
 
public:
 
    explicit MapUndoStack(QObject *parent = nullptr);
 
    [[nodiscard]] int maxUndoCount() const;
 
    void setMaxUndoCount(int count);
 
    void loadSettings();
 
    void saveSettings() const;
 
signals:
    void maxUndoCountChanged(int count);
 
private:
    static constexpr int DefaultMaxUndoCount = 50;
};
 
// ---------------------------------------------------------------------------
// Base class for all undoable map commands
// ---------------------------------------------------------------------------
 
class MapCanvas;
class OpenSWMMVisLayer;
 
class MapCommand : public QUndoCommand
{
public:
 
    explicit MapCommand(const QString &text, MapCanvas *canvas, QUndoCommand *parent = nullptr);
 
    [[nodiscard]] MapCanvas *canvas() const;
 
protected:
    MapCanvas *m_canvas; 
};
 
// ---------------------------------------------------------------------------
// Concrete commands
// ---------------------------------------------------------------------------
 
class MapExtent;
class SpatialReferenceSystem;
class SWMMModelLayer;
 
class PanZoomCommand : public MapCommand
{
public:
    PanZoomCommand(const MapExtent &oldExtent,
                   const MapExtent &newExtent,
                   MapCanvas *canvas,
                   QUndoCommand *parent = nullptr);
 
    void undo() override;
    void redo() override;
 
    bool mergeWith(const QUndoCommand *other) override;
    int id() const override { return 1; }
 
private:
    MapExtent m_oldExtent;
    MapExtent m_newExtent;
};
 
class ChangeCRSCommand : public MapCommand
{
public:
    ChangeCRSCommand(const QString &oldAuthCode,
                     const QString &newAuthCode,
                     MapCanvas *canvas,
                     QUndoCommand *parent = nullptr);
 
    void undo() override;
    void redo() override;
 
private:
    QString m_oldAuthCode;  
    QString m_newAuthCode;
    bool    m_firstRedo = true; 
};
 
class AddLayerCommand : public MapCommand
{
public:
    AddLayerCommand(OpenSWMMVisLayer *layer, int position, MapCanvas *canvas,
                    QUndoCommand *parent = nullptr);
 
    void undo() override;
    void redo() override;
 
private:
    OpenSWMMVisLayer *m_layer;    
    int           m_position;
};
 
class RemoveLayerCommand : public MapCommand
{
public:
    RemoveLayerCommand(OpenSWMMVisLayer *layer, int position, MapCanvas *canvas,
                       QUndoCommand *parent = nullptr);
 
    void undo() override;
    void redo() override;
 
private:
    OpenSWMMVisLayer *m_layer;
    int           m_position;
};
 
class MoveLayerCommand : public MapCommand
{
public:
    MoveLayerCommand(int oldIndex, int newIndex, MapCanvas *canvas,
                     QUndoCommand *parent = nullptr);
 
    void undo() override;
    void redo() override;
 
private:
    int m_oldIndex;
    int m_newIndex;
};
 
class MoveSublayerCommand : public MapCommand
{
public:
    MoveSublayerCommand(OpenSWMMVisLayer *host, int fromIndex, int toIndex,
                        MapCanvas *canvas, QUndoCommand *parent = nullptr);
 
    void undo() override;
    void redo() override;
 
private:
    OpenSWMMVisLayer *m_host;   
    int m_fromIndex;
    int m_toIndex;
};
 
// ---------------------------------------------------------------------------
// Phase 2 — Interactive map editing
// ---------------------------------------------------------------------------
 
class MoveNodeCommand : public MapCommand
{
public:
    struct LengthRec
    {
        int    linkIdx;
        double oldLen;
        double newLen;
    };
 
    MoveNodeCommand(SWMMModelLayer *layer,
                    int nodeIdx,
                    double oldX, double oldY,
                    double newX, double newY,
                    QVector<LengthRec> lengthRecs,
                    MapCanvas *canvas,
                    QUndoCommand *parent = nullptr);
 
    void undo() override;
    void redo() override;
 
    int id() const override { return 10; }
    bool mergeWith(const QUndoCommand *other) override;
 
private:
    SWMMModelLayer     *m_layer   = nullptr;
    int                 m_nodeIdx = -1;
    double              m_oldX    = 0.0;
    double              m_oldY    = 0.0;
    double              m_newX    = 0.0;
    double              m_newY    = 0.0;
    QVector<LengthRec>  m_lengthRecs;
};
 
class MoveGageCommand : public MapCommand
{
public:
    MoveGageCommand(SWMMModelLayer *layer,
                    int gageIdx,
                    double oldX, double oldY,
                    double newX, double newY,
                    MapCanvas *canvas,
                    QUndoCommand *parent = nullptr);
 
    void undo() override;
    void redo() override;
 
    int id() const override { return 14; }
    bool mergeWith(const QUndoCommand *other) override;
 
private:
    SWMMModelLayer *m_layer   = nullptr;
    int             m_gageIdx = -1;
    double          m_oldX    = 0.0;
    double          m_oldY    = 0.0;
    double          m_newX    = 0.0;
    double          m_newY    = 0.0;
};
 
class EditVertexCommand : public MapCommand
{
public:
    EditVertexCommand(SWMMModelLayer *layer,
                      int linkIdx,
                      QVector<QPointF> oldInterior,
                      QVector<QPointF> newInterior,
                      double oldLen,
                      double newLen,
                      bool autoLengthApplied,
                      MapCanvas *canvas,
                      QUndoCommand *parent = nullptr);
 
    void undo() override;
    void redo() override;
 
    int id() const override { return 11; }
 
private:
    SWMMModelLayer     *m_layer   = nullptr;
    int                 m_linkIdx = -1;
    QVector<QPointF>    m_oldInterior;
    QVector<QPointF>    m_newInterior;
    double              m_oldLen  = 0.0;
    double              m_newLen  = 0.0;
    bool                m_autoLengthApplied = false;
};
 
class FlipLinkCommand : public MapCommand
{
public:
    FlipLinkCommand(SWMMModelLayer *layer,
                    int linkIdx,
                    MapCanvas *canvas,
                    QUndoCommand *parent = nullptr);
 
    void undo() override;
    void redo() override;
 
    int id() const override { return 13; }
 
private:
    SWMMModelLayer *m_layer   = nullptr;
    int             m_linkIdx = -1;
};
 
class EditSubcatchCommand : public MapCommand
{
public:
    EditSubcatchCommand(SWMMModelLayer *layer,
                        int catchIdx,
                        QVector<QPointF> oldVertices,
                        QVector<QPointF> newVertices,
                        double oldArea,
                        double newArea,
                        bool applyArea,
                        MapCanvas *canvas,
                        QUndoCommand *parent = nullptr);
 
    void undo() override;
    void redo() override;
 
    int id() const override { return 12; }
 
private:
    SWMMModelLayer  *m_layer    = nullptr;
    int              m_catchIdx = -1;
    QVector<QPointF> m_old;
    QVector<QPointF> m_new;
    double           m_oldArea  = 0.0;
    double           m_newArea  = 0.0;
    bool             m_applyArea= false;
};
 
class AddNodeCommand : public MapCommand
{
public:
    AddNodeCommand(SWMMModelLayer *layer,
                   QString name,
                   int nodeType,
                   double x, double y,
                   MapCanvas *canvas,
                   double invertElev = 0.0,
                   QUndoCommand *parent = nullptr);
 
    void undo() override;
    void redo() override;
 
    int id() const override { return 12; }
 
private:
    SWMMModelLayer *m_layer      = nullptr;
    QString         m_name;
    int             m_nodeType   = 0;
    double          m_x          = 0.0;
    double          m_y          = 0.0;
    double          m_invertElev = 0.0;
    bool            m_present    = false;  // true iff currently applied
};
 
class AddLinkCommand : public MapCommand
{
public:
    AddLinkCommand(SWMMModelLayer   *layer,
                   QString           name,
                   int               linkType,
                   QString           fromNode,
                   QString           toNode,
                   QVector<QPointF>  interiorVertices,
                   MapCanvas        *canvas,
                   double            offsetUp = 0.0,
                   double            offsetDn = 0.0,
                   QUndoCommand     *parent = nullptr);
 
    void undo() override;
    void redo() override;
    int  id()   const override { return 13; }
 
private:
    SWMMModelLayer  *m_layer    = nullptr;
    QString          m_name;
    int              m_linkType = 0;
    QString          m_fromNode;
    QString          m_toNode;
    QVector<QPointF> m_interiorVertices;
    double           m_offsetUp = 0.0;
    double           m_offsetDn = 0.0;
    bool             m_present  = false;
    int              m_linkIdx  = -1; // engine index, used for auto-length
};
 
class AddGageCommand : public MapCommand
{
public:
    AddGageCommand(SWMMModelLayer *layer,
                   QString         name,
                   double          x, double y,
                   MapCanvas      *canvas,
                   QUndoCommand   *parent = nullptr);
 
    void undo() override;
    void redo() override;
    int  id()   const override { return 14; }
 
private:
    SWMMModelLayer *m_layer = nullptr;
    QString         m_name;
    double          m_x = 0, m_y = 0;
    bool            m_present = false;
};
 
class AddSubcatchmentCommand : public MapCommand
{
public:
    AddSubcatchmentCommand(SWMMModelLayer   *layer,
                           QString           name,
                           QVector<QPointF>  polygon,
                           MapCanvas        *canvas,
                           QUndoCommand     *parent = nullptr);
 
    void undo() override;
    void redo() override;
    int  id()   const override { return 15; }
 
private:
    SWMMModelLayer  *m_layer = nullptr;
    QString          m_name;
    QVector<QPointF> m_polygon;
    bool             m_present  = false;
    int              m_subcatchIdx = -1; // engine index, used for auto-area
};
 
class AssignSubcatchGagesCommand : public MapCommand
{
public:
    AssignSubcatchGagesCommand(SWMMModelLayer *layer,
                               QStringList     subcatchNames,
                               QStringList     newGages,
                               QStringList     oldGages,
                               const QString  &text,
                               MapCanvas      *canvas,
                               QUndoCommand   *parent = nullptr);
 
    void undo() override;
    void redo() override;
    int  id()   const override { return 47; }
 
private:
    void apply(const QStringList &gages);
 
    SWMMModelLayer *m_layer = nullptr;
    QStringList     m_subcatchNames;
    QStringList     m_newGages;
    QStringList     m_oldGages;
};
 
class ConfigureGageCommand : public MapCommand
{
public:
    struct Config
    {
        int     dataSource  = 0;     
        QString timeseries;          
        int     rainType    = 0;     
        double  intervalSec = 3600;  
        double  scaleFactor = 1.0;
        double  snowFactor  = 1.0;
    };
 
    [[nodiscard]] static Config capture(SWMMModelLayer *layer,
                                        const QString &gageName,
                                        bool *ok = nullptr);
 
    ConfigureGageCommand(SWMMModelLayer *layer,
                         QString         gageName,
                         Config          newConfig,
                         Config          oldConfig,
                         MapCanvas      *canvas,
                         QUndoCommand   *parent = nullptr);
 
    void undo() override;
    void redo() override;
    int  id()   const override { return 48; }
 
private:
    void apply(const Config &c);
 
    SWMMModelLayer *m_layer = nullptr;
    QString         m_gageName;
    Config          m_new;
    Config          m_old;
};
 
class BulkEditCommand : public QUndoCommand
{
public:
    BulkEditCommand(SWMMModelLayer *layer, const QString &text,
                    QUndoCommand *parent = nullptr)
        : QUndoCommand(text, parent), m_layer(layer) {}
 
    void redo() override
    {
        SWMMModelLayer::BulkEdit guard(m_layer);
        QUndoCommand::redo();
    }
 
    void undo() override
    {
        SWMMModelLayer::BulkEdit guard(m_layer);
        QUndoCommand::undo();
    }
 
private:
    QPointer<SWMMModelLayer> m_layer;
};
 
class DeleteObjectCommand : public MapCommand
{
public:
    enum TargetKind { DeleteNode, DeleteLink, DeleteGage, DeleteSubcatch };
 
    DeleteObjectCommand(SWMMModelLayer *layer, const QString &name,
                        TargetKind kind, MapCanvas *canvas,
                        QUndoCommand *parent = nullptr);
 
    void setEngineAppliedByBatch(bool b) { m_engineAppliedByBatch = b; }
 
    void undo() override;
    void redo() override;
    int  id()   const override { return 16; }
 
private:
    void snapshotNode(const QString &name);
    void snapshotLink(const QString &name);
    void snapshotGage(const QString &name);
    void snapshotSubcatch(const QString &name);
    void restoreNode();
    void restoreLink();
    void restoreGage();
    void restoreSubcatch();
 
    SWMMModelLayer      *m_layer = nullptr;
    TargetKind           m_kind;
    bool                 m_engineAppliedByBatch = false;
    NodeSnapshot         m_node;
    QVector<LinkSnapshot> m_cascadeLinks; // cascade-deleted links when a node is deleted
    LinkSnapshot         m_link;
    GageSnapshot         m_gage;
    SubcatchSnapshot     m_subcatch;
};
 
class BatchDeleteCommand : public BulkEditCommand
{
public:
    struct Target { QString name; DeleteObjectCommand::TargetKind kind; };
 
    BatchDeleteCommand(SWMMModelLayer *layer, const QList<Target> &targets,
                       MapCanvas *canvas, const QString &text);
 
    void redo() override;
 
private:
    QPointer<SWMMModelLayer> m_layer;
    QStringList m_nodeNames, m_linkNames, m_subcatchNames, m_gageNames;
};
 
class DeleteDataObjectCommand : public MapCommand
{
public:
    DeleteDataObjectCommand(SWMMModelLayer *layer,
                            const SWMMObjectRef &ref,
                            MapCanvas *canvas,
                            QUndoCommand *parent = nullptr);
 
    void undo() override;
    void redo() override;
    int  id()   const override { return 17; }
 
    static bool supports(SWMMObjectRef::ObjectType type);
 
private:
    void snapshotCurve();       void restoreCurve();
    void snapshotTimeSeries();  void restoreTimeSeries();
    void snapshotTransect();    void restoreTransect();
 
    SWMMModelLayer *m_layer = nullptr;
    SWMMObjectRef   m_ref;
    bool            m_captured = false;   // snapshot succeeded
 
    // --- Curve snapshot ---
    int              m_curveType = -1;    // openswmmvis::curve::CurveType as int
    QVector<QPointF> m_curvePoints;       // (x, y)
 
    // --- Time series snapshot ---
    QString   m_tsUnits, m_tsDescription;
    int       m_tsSourceMode = 0;         // TimeseriesProvider::SourceMode as int
    QString   m_tsFilePath, m_tsColumnSelector;
    QDateTime m_tsFileMTime;
    QVector<QPair<QDateTime, double>> m_tsPoints;   // (time, value)
 
    // --- Transect snapshot ---
    QString m_txComments;
    double  m_txNLeft = 0, m_txNRight = 0, m_txNChannel = 0;
    double  m_txXLeftBank = 0, m_txXRightBank = 0;
    double  m_txXLeftEncroach = 0, m_txXRightEncroach = 0;
    double  m_txXFactor = 1, m_txYFactor = 1, m_txLengthFactor = 1;
    QVector<QPair<double, double>> m_txPoints;      // (station, elevation)
};
 
class ReorderLayersCommand : public MapCommand
{
public:
    ReorderLayersCommand(QList<OpenSWMMVisLayer *> oldOrder,
                         QList<OpenSWMMVisLayer *> newOrder,
                         MapCanvas *canvas,
                         QUndoCommand *parent = nullptr);
    void undo() override;
    void redo() override;
 
private:
    QList<OpenSWMMVisLayer *> m_oldOrder;
    QList<OpenSWMMVisLayer *> m_newOrder;
    bool m_firstRedo = true;
};
 
// ---------------------------------------------------------------------------
// Object Browser reorder commands (Slice AY)
// ---------------------------------------------------------------------------
 
class ReorderCategoriesCommand : public QUndoCommand
{
public:
    ReorderCategoriesCommand(SWMMModelLayer *layer,
                              QVector<SWMMModelLayer::Category> oldOrder,
                              QVector<SWMMModelLayer::Category> newOrder,
                              QUndoCommand *parent = nullptr);
    void undo() override;
    void redo() override;
 
private:
    SWMMModelLayer                    *m_layer;
    QVector<SWMMModelLayer::Category>  m_oldOrder;
    QVector<SWMMModelLayer::Category>  m_newOrder;
    bool                               m_firstRedo = true;
};
 
class ReorderObjectsCommand : public QUndoCommand
{
public:
    ReorderObjectsCommand(SWMMModelLayer         *layer,
                          SWMMModelLayer::Category cat,
                          QVector<int>             oldOrder,  // empty = was default
                          QVector<int>             newOrder,
                          QUndoCommand            *parent = nullptr);
    void undo() override;
    void redo() override;
 
private:
    SWMMModelLayer          *m_layer;
    SWMMModelLayer::Category m_cat;
    QVector<int>             m_oldOrder;  // empty means "was default before this cmd"
    QVector<int>             m_newOrder;
    bool                     m_firstRedo = true;
};
 
class OpenSWMMVisAnnotationLayer;
class AnnotationTextItem;
 
class AddAnnotationCommand : public MapCommand
{
public:
    AddAnnotationCommand(OpenSWMMVisAnnotationLayer *layer,
                         AnnotationTextItem *item,
                         MapCanvas *canvas,
                         QUndoCommand *parent = nullptr);
    ~AddAnnotationCommand() override;
 
    void undo() override;
    void redo() override;
    int  id()   const override { return 21; }
 
private:
    OpenSWMMVisAnnotationLayer *m_layer = nullptr;
    AnnotationTextItem         *m_item  = nullptr;  
    QString                     m_itemId;            
    bool                        m_present = false;   
};
 
class InsertVirtualJunctionCommand : public MapCommand
{
public:
    InsertVirtualJunctionCommand(SWMMModelLayer *layer,
                                 QString linkName, double t,
                                 QString nodeName, QString newLinkName,
                                 MapCanvas *canvas,
                                 QUndoCommand *parent = nullptr);
 
    void undo() override;
    void redo() override;
    int  id()   const override { return 22; }
 
private:
    SWMMModelLayer *m_layer = nullptr;
    QString m_linkName;      
    double  m_t = 0.5;       
    QString m_nodeName;      
    QString m_newLinkName;   
    bool    m_present = false;
};
 
class InsertJunctionSplitCommand : public MapCommand
{
public:
    InsertJunctionSplitCommand(SWMMModelLayer *layer,
                               QString linkName, double t,
                               QString nodeName, QString newLinkName,
                               MapCanvas *canvas,
                               QUndoCommand *parent = nullptr);
 
    void undo() override;
    void redo() override;
    int  id()   const override { return 27; }
 
private:
    SWMMModelLayer *m_layer = nullptr;
    QString m_linkName;      
    double  m_t = 0.5;       
    QString m_nodeName;      
    QString m_newLinkName;   
    bool    m_present = false;
};
 
class InsertNodeSplitCommand : public MapCommand
{
public:
    InsertNodeSplitCommand(SWMMModelLayer *layer,
                           QString linkName, double t,
                           QString nodeName, QString newLinkName,
                           int nodeType,
                           MapCanvas *canvas,
                           QUndoCommand *parent = nullptr);
 
    void undo() override;
    void redo() override;
    int  id()   const override { return 49; }
 
    [[nodiscard]] QStringList warnings() const { return m_warnings; }
    [[nodiscard]] bool retyped() const { return m_retyped; }
 
private:
    SWMMModelLayer *m_layer = nullptr;
    QString m_linkName;      
    double  m_t = 0.5;       
    QString m_nodeName;      
    QString m_newLinkName;   
    int     m_nodeType = 0;  
    bool    m_present = false;
    bool    m_retyped = false;
    QStringList m_warnings;
};
 
class FuseVirtualJunctionCommand : public MapCommand
{
public:
    FuseVirtualJunctionCommand(SWMMModelLayer *layer,
                               QString nodeName,
                               MapCanvas *canvas,
                               QUndoCommand *parent = nullptr);
 
    void undo() override;
    void redo() override;
    int  id()   const override { return 23; }
 
    bool valid() const { return m_valid; }
 
private:
    SWMMModelLayer *m_layer = nullptr;
    QString m_nodeName;
    QString m_upLinkName;    
    QString m_dnLinkName;    
    double  m_t = 0.5;       
    double  m_invert = 0.0;  
    double  m_x = 0.0, m_y = 0.0;
    bool    m_valid   = false;
    bool    m_present = false;   
};
 
class SetInletUsageCommand : public MapCommand
{
public:
    SetInletUsageCommand(SWMMModelLayer *layer,
                         const SWMM_InletUsage &newUsage,
                         bool removing,
                         MapCanvas *canvas,
                         QUndoCommand *parent = nullptr);
 
    void undo() override;
    void redo() override;
    int  id()   const override { return 24; }
 
private:
    SWMMModelLayer *m_layer = nullptr;
    SWMM_InletUsage m_new{};
    SWMM_InletUsage m_old{};
    bool m_removing  = false;   
    bool m_hadOld    = false;   
};
 
class InsertInletJunctionCommand : public MapCommand
{
public:
    InsertInletJunctionCommand(SWMMModelLayer *layer,
                               QString linkName, double t,
                               QString nodeName, QString newLinkName,
                               QString inletId, QString captureNode,
                               MapCanvas *canvas,
                               QUndoCommand *parent = nullptr);
 
    void undo() override;
    void redo() override;
    int  id()   const override { return 25; }
 
private:
    SWMMModelLayer *m_layer = nullptr;
    QString m_linkName;      
    double  m_t = 0.5;       
    QString m_nodeName;      
    QString m_newLinkName;   
    QString m_inletId;       
    QString m_captureNode;   
    bool    m_present = false;
};
 
class FuseInletJunctionCommand : public MapCommand
{
public:
    FuseInletJunctionCommand(SWMMModelLayer *layer,
                             QString nodeName,
                             MapCanvas *canvas,
                             QUndoCommand *parent = nullptr);
 
    void undo() override;
    void redo() override;
    int  id()   const override { return 26; }
 
    bool valid() const { return m_valid; }
 
private:
    SWMMModelLayer *m_layer = nullptr;
    QString m_nodeName;
    QString m_upLinkName;    
    QString m_dnLinkName;    
    double  m_t = 0.5;       
    double  m_invert = 0.0;  
    double  m_x = 0.0, m_y = 0.0;
    QString m_inletId;       
    QString m_captureNode;   
    SWMM_InletUsage m_usage{};   
    bool    m_valid   = false;
    bool    m_present = false;   
};
 
#endif // MAPUNDOSTACK_H