SettingsBasin.h

#ifndef HYDROBRICKS_SETTING_BASIN_H
#define HYDROBRICKS_SETTING_BASIN_H
 
#include "Includes.h"
#include "Parameter.h"
 
struct LandCoverSettings {
    string name;
    string type;
    double fraction;
};
 
struct SurfaceComponentSettings {
    string name;
    string type;
    double fraction;
};
 
struct HydroUnitPropertyDouble {
    string name;
    double value;
    string unit;
};
 
struct HydroUnitPropertyString {
    string name;
    string value;
};
 
struct HydroUnitSettings {
    int id;
    double area;
    double elevation;
    vector<LandCoverSettings> landCovers;
    vector<SurfaceComponentSettings> surfaceComponents;
    vector<HydroUnitPropertyDouble> propertiesDouble;
    vector<HydroUnitPropertyString> propertiesString;
};
 
struct LateralConnectionSettings {
    string type;
    int giverHydroUnitId;
    int receiverHydroUnitId;
    double fraction;
};
 
class SettingsBasin {
  public:
    explicit SettingsBasin();
 
    virtual ~SettingsBasin();
 
    void AddHydroUnit(int id, double area, double elevation = -9999);
 
    void AddLandCover(const string& name, const string& type = "", double fraction = 1.0);
 
    void AddHydroUnitPropertyDouble(const string& name, double value, const string& unit = "");
 
    void AddHydroUnitPropertyString(const string& name, const string& value);
 
    void AddLateralConnection(int giverHydroUnitId, int receiverHydroUnitId, double fraction, const string& type = "");
 
    void Clear();
 
    void SelectUnit(int index);
 
    bool Parse(const string& path);
 
    HydroUnitSettings GetHydroUnitSettings(int index) const {
        assert(_hydroUnits.size() > index);
        return _hydroUnits[index];
    }
 
    LandCoverSettings GetLandCoverSettings(int index) const {
        assert(_selectedHydroUnit);
        assert(_selectedHydroUnit->landCovers.size() > index);
        return _selectedHydroUnit->landCovers[index];
    }
 
    SurfaceComponentSettings GetSurfaceComponentSettings(int index) const {
        assert(_selectedHydroUnit);
        assert(_selectedHydroUnit->surfaceComponents.size() > index);
        return _selectedHydroUnit->surfaceComponents[index];
    }
 
    vector<LateralConnectionSettings> GetLateralConnections() const {
        return _lateralConnections;
    }
 
    int GetHydroUnitCount() const {
        return static_cast<int>(_hydroUnits.size());
    }
 
    int GetLandCoverCount() const {
        assert(_selectedHydroUnit);
        return static_cast<int>(_selectedHydroUnit->landCovers.size());
    }
 
    int GetSurfaceComponentCount() const {
        assert(_selectedHydroUnit);
        return static_cast<int>(_selectedHydroUnit->surfaceComponents.size());
    }
 
    int GetLateralConnectionCount() const {
        return static_cast<int>(_lateralConnections.size());
    }
 
    [[nodiscard]] double GetTotalArea() const;
 
  private:
    vector<HydroUnitSettings> _hydroUnits;
    vector<LateralConnectionSettings> _lateralConnections;
    HydroUnitSettings* _selectedHydroUnit;  // non-owning reference
};
 
#endif  // HYDROBRICKS_SETTING_BASIN_H