Splitter.h

#ifndef HYDROBRICKS_SPLITTER_H
#define HYDROBRICKS_SPLITTER_H
 
#include <memory>
 
#include "Flux.h"
#include "Forcing.h"
#include "Includes.h"
#include "SettingsModel.h"
 
class HydroUnit;
 
class Splitter {
  public:
    explicit Splitter();
 
    virtual ~Splitter() = default;
 
    static std::unique_ptr<Splitter> Factory(const SplitterSettings& splitterSettings);
 
    [[nodiscard]] virtual bool IsValid() const = 0;
 
    virtual void Validate() const;
 
    virtual void SetParameters(const SplitterSettings& splitterSettings) = 0;
 
    const float* GetParameterValuePointer(const SplitterSettings& splitterSettings, const string& name);
 
    const float* GetParameterValuePointerOrUnit(const SplitterSettings& splitterSettings, const string& name);
 
    virtual void AttachForcing(Forcing*) {
        throw ShouldNotHappen("Splitter::AttachForcing - Should not be called (virtual)");
    }
 
    virtual void SetHydroUnitProperties(HydroUnit* /*unit*/) {}
 
    void AttachFluxIn(Flux* flux) {
        assert(flux);
        _inputs.push_back(flux);
    }
 
    void AttachFluxOut(std::unique_ptr<Flux> flux) {
        assert(flux);
        _outputs.push_back(std::move(flux));
    }
 
    virtual double* GetValuePointer(const string& name) = 0;
 
    virtual void Compute() = 0;
 
    const string& GetName() const {
        return _name;
    }
 
    void SetName(const string& name) {
        _name = name;
    }
 
  protected:
    string _name;
    vector<Flux*> _inputs;                        // non-owning: owned by processes
    std::vector<std::unique_ptr<Flux>> _outputs;  // owning
    const float _unitValue = 1.0f;                // fallback for absent optional parameters
};
 
#endif  // HYDROBRICKS_SPLITTER_H