DependentParameter.h

Go to the documentation of this file.

#ifndef DEPENDENT_PARAMETER_H
#define DEPENDENT_PARAMETER_H
 
#include <functional>
#include <memory>
#include <unordered_map>
 
#include "Parameter.h"
 
class ParamSrc;
class DependentParameter;
 
typedef std::function<void(const ParamSrc&, std::shared_ptr<DependentParameter>)> DepParamUpdateFunc;
 
class DependentParameter : public Parameter {
public:
    explicit DependentParameter(ParamId pid, std::unordered_map<ParamId, std::shared_ptr<Parameter>> sources, DepParamUpdateFunc recalculateFunc);
 
    bool dependsOn(const ParamId& pid);
 
    void init();
 
    void update() override;
 
    void freeze() override;
 
    void unfreeze() override;
 
    void clear_above() override;
 
    void clear_below() override;
 
    std::unordered_map<ParamId, std::shared_ptr<Parameter>> get_source_parameters() const override {
        return this->sources_raw;
    }
 
    scalar_t get_val() const override;
    
    void mark_dirty();
 
    void ensure_up_to_date();
 
    void rebind(std::unordered_map<ParamId, std::shared_ptr<Parameter>> new_sources,
            DepParamUpdateFunc new_lambda);
        
    void detach();
 
    void reattach();
 
    ~DependentParameter();
    
private:
    std::weak_ptr<DependentParameter> self;                                 
    std::unordered_map<ParamId, std::shared_ptr<Parameter>> sources_raw;    
    std::unique_ptr<ParamSrc> sources;                                      
    DepParamUpdateFunc recalculateLambda;                                   
    bool frozen {false};                                                    
    bool update_at_unfreeze {false};                                        
    bool dirty = true;                                                      
 
    std::unordered_map<ParamId, std::shared_ptr<Parameter>> saved_sources_raw;
 
    DepParamUpdateFunc saved_recalculateLambda;
 
    bool dependency_detached = false;
};
 
inline std::shared_ptr<Parameter>& operator+=(std::shared_ptr<Parameter>& lhs, const std::shared_ptr<Parameter>& rhs) {
    if (rhs) {
        if (lhs && lhs->get_id() == rhs->get_id()) {
            *lhs += *rhs;
        }
        else
            lhs = std::make_shared<Parameter>(*rhs);
    }
    return lhs;
}
 
inline std::shared_ptr<Parameter>& operator*(std::shared_ptr<Parameter>& lhs, const scalar_t& rhs) {
    if (rhs) {
        *lhs *= rhs;
    }
    return lhs;
}
 
#endif