Block.h

Go to the documentation of this file.

#ifndef BLOCK_H
#define BLOCK_H
 
#include <array>
#include <functional>
 
#include "Include.h"
#include "Parameter.h"
#include "IStorage.h"
 
class BlockSrc;
class Block;
class DependentBlock;
 
typedef std::function<void(const BlockSrc&, std::shared_ptr<DependentBlock>)> DepUpdateFunc;
 
 
class Block : public IStorage<LhaID, Parameter>, public std::enable_shared_from_this<Block> {
public:
    BlockName blockname {""};
 
    Block() = default;
 
    Block(std::shared_ptr<Block> other);
 
    BlockName get_name() const { return this->blockname; }
 
    void store(const LhaID& id, std::shared_ptr<Parameter> param) override;
 
    void assign(const LhaID& key, std::shared_ptr<Parameter> param) override;
 
    void assign(const LhaID& key, scalar_t value);
 
    void store_or_assign(const LhaID& key, std::shared_ptr<Parameter> param) override;
 
    bool contains(const LhaID& key) const override;
 
    std::shared_ptr<Parameter> retrieve(const LhaID& id) override;
 
    void remove(const LhaID& key) override;
 
    std::unordered_set<LhaID> getAllIDs();
 
    const std::map<LhaID, std::shared_ptr<Parameter>>& getItems();
 
    void set_owner(ParameterType type);
 
    void addObserver(std::shared_ptr<Block> observer);
 
    void removeObserver(std::shared_ptr<Block> observer);
 
    void notifyObservers();
 
    std::vector<std::shared_ptr<Block>> getObservers() const;
 
    virtual void init() {};
    
    virtual void update();
 
    virtual void destroy();
    
    virtual void freeze();
 
    virtual void unfreeze();
 
    void copy(std::shared_ptr<Block> other);
 
    std::shared_ptr<Block> deep_clone_plain() const;
 
    virtual void clear_above();
 
    virtual void clear_below();
 
    bool has_scale();
 
    void set_scale(double scale);
 
    double get_scale();
 
    void erase_local(const LhaID& id);
 
    virtual std::unordered_map<std::string, std::shared_ptr<Block>> get_source_blocks() const;
 
    virtual void ensure_up_to_date() {}
 
    void bind_self(std::shared_ptr<Block> self) {
        self_ = self;
 
        std::weak_ptr<Block> w(self);
        for (auto& [_, p] : items) {
            if (p) p->set_owner_block(w);
        }
    }
 
    ~Block() {}
 
    friend std::ostream& operator<<(std::ostream&, std::shared_ptr<Block>);
protected:
    std::vector<std::shared_ptr<Block>> observers;      
    std::map<LhaID, std::shared_ptr<Parameter>> items;  
    std::optional<double> scale;                        
 
    std::weak_ptr<Block> self_;                         
 
    std::weak_ptr<Block> self_weak() {
        if (auto s = self_.lock()) return self_;
        try { return shared_from_this(); } catch (...) { return {}; }
    }
};
 
class DependentBlock : public Block {
public:
    explicit DependentBlock(
    const std::unordered_map<std::string, std::shared_ptr<Block>>& sources,
    DepUpdateFunc recalculateFunc)
    : sourceBlocks(sources),
      recalculateLambda(recalculateFunc),
      saved_sourceBlocks(sources),
      saved_recalculateLambda(recalculateFunc),
      frozen(false) {}
 
    bool dependsOn(const std::string& blockName);
 
    void init() override;
 
    void update() override;
 
    void freeze() override;
 
    void unfreeze() override;
 
    void detach();
 
    void reattach();
 
    ~DependentBlock();
 
    void assign(const LhaID& key, std::shared_ptr<Parameter> param);
 
    void assign(const LhaID& key, double value);
 
    std::unordered_map<std::string, std::shared_ptr<Block>> get_source_blocks() const override;
 
    void clear_above() override;
 
    void clear_below() override;
 
    void destroy() override;
 
    void mark_dirty();
 
    void ensure_up_to_date() override { ensure_up_to_date_impl(); }
 
private:
    void ensure_up_to_date_impl();
 
    std::weak_ptr<DependentBlock> self;                                     
    std::unordered_map<std::string, std::shared_ptr<Block>> sourceBlocks;   
    DepUpdateFunc recalculateLambda;                                        
    bool frozen = false;                                                    
    bool update_at_unfreeze = false;                                        
    bool dirty = true;                                                      
 
    std::unordered_map<std::string, std::shared_ptr<Block>> saved_sourceBlocks;
 
    DepUpdateFunc saved_recalculateLambda;
 
    bool dependency_detached = false;
};
 
#endif