BlockAccessor.h

Go to the documentation of this file.

#ifndef BLOCK_ACCESSOR_H
#define BLOCK_ACCESSOR_H
 
#include <functional>
#include <unordered_map>
 
#include "Include.h"
#include "Block.h"
#include "DependentParameter.h"
 
class BlockAccessor : public std::unordered_map<std::string, std::shared_ptr<Block>> {
public:
 
    using base_t = std::unordered_map<std::string, std::shared_ptr<Block>>;
 
    using base_t::operator[];
 
    bool has_param(const BlockName& blockName, LhaID pdgCode) const;
 
    void setValue(const BlockName& blockName, LhaID pdgCode, scalar_t value);
 
    scalar_t getValue(const BlockName& blockName, LhaID pdgCode) const;
 
    std::shared_ptr<Parameter> getParameter(const BlockName& blockName, LhaID id) const;
 
    void setParameter(const BlockName& blockName, LhaID id, std::shared_ptr<Parameter> source);
 
    std::map<LhaID, scalar_t> getAllValues(BlockName blockName);
 
    std::unordered_set<BlockName> get_block_names() const;
 
    void remove_item(const BlockName& block_name, LhaID id);
 
    bool contains(const BlockName& block_name) const;
 
    double get_scale(const BlockName& block_name) const;
 
    bool has_scale(const BlockName& block_name) const;
 
    std::unordered_map<std::string, std::shared_ptr<Block>> get_block_sources(const BlockName& block_name) const;
 
    std::unordered_map<ParamId, std::shared_ptr<Parameter>> get_parameter_sources(const BlockName& block_name, LhaID id) const;
 
    std::unordered_set<ParamId>
    get_all_source_parameters(const std::unordered_set<ParamId>& param_ids) const;
    
    bool is_dependent_block(const BlockName& block_name) const;
 
    std::vector<std::string> get_source_block_names(const BlockName& block_name) const;
 
    std::vector<std::string> get_dependent_block_names(const BlockName& block_name) const;
 
    std::vector<std::string> get_all_source_block_names(const BlockName& block_name) const;
 
    std::vector<std::string> get_all_dependent_block_names(const BlockName& block_name) const;
    
    std::shared_ptr<Block>& at(const BlockName& block_name);
 
    const std::shared_ptr<Block>& at(const BlockName& block_name) const;
 
    friend std::shared_ptr<BlockAccessor> operator+(std::shared_ptr<BlockAccessor> lhs, std::shared_ptr<BlockAccessor> rhs);
 
    friend std::shared_ptr<BlockAccessor> operator>>(std::shared_ptr<BlockAccessor> lhs, std::shared_ptr<BlockAccessor> rhs);
 
    std::shared_ptr<BlockAccessor> operator[](std::unordered_set<BlockName> block_names);
    
    friend std::ostream& operator<<(std::ostream&, std::shared_ptr<BlockAccessor>);
 
    void emplace(const BlockName& name, std::shared_ptr<Block> blk);
 
    std::shared_ptr<BlockAccessor> deep_clone_plain() const;
    
    void detach_block(const BlockName& block_name);
 
    void reattach_block(const BlockName& block_name);
 
    void detach_parameter(const BlockName& block_name, LhaID id);
 
    void reattach_parameter(const BlockName& block_name, LhaID id);
 
    void erase_block(const BlockName& name);
 
 
    void erase_block(const std::string& name) { return erase_block(std::string_view{name}); }
    void erase_block(const char* name) { return erase_block(std::string_view{name}); }
 
    bool contains(const std::string& name) const { return contains(std::string_view{name}); }
    bool contains(const char* name) const { return contains(std::string_view{name}); }
 
    std::shared_ptr<Block>& at(const std::string& name) { return at(std::string_view{name}); }
    const std::shared_ptr<Block>& at(const std::string& name) const { return at(std::string_view{name}); }
    std::shared_ptr<Block>& at(const char* name) { return at(std::string_view{name}); }
    const std::shared_ptr<Block>& at(const char* name) const { return at(std::string_view{name}); }
 
    void emplace(const std::string& name, std::shared_ptr<Block> blk) { emplace(BlockName(name), std::move(blk)); }
    void emplace(const char* name, std::shared_ptr<Block> blk) { emplace(BlockName(name), std::move(blk)); }
 
    bool has_param(const std::string& block, const LhaID& id) const { return has_param(std::string_view{block}, id); }
    bool has_param(const char* block, const LhaID& id) const { return has_param(std::string_view{block}, id); }
 
    scalar_t getValue(const std::string& block, const LhaID& id) const { return getValue(std::string_view{block}, id); }
    scalar_t getValue(const char* block, const LhaID& id) const { return getValue(std::string_view{block}, id); }
 
    void setValue(const std::string& block, const LhaID& id, scalar_t v) { setValue(std::string_view{block}, id, v); }
    void setValue(const char* block, const LhaID& id, scalar_t v) { setValue(std::string_view{block}, id, v); }
 
    void remove_item(const std::string& block, const LhaID& id) { remove_item(std::string_view{block}, id); }
    void remove_item(const char* block, const LhaID& id) { remove_item(std::string_view{block}, id); }
 
    bool has_scale(const std::string& block) const { return has_scale(std::string_view{block}); }
    bool has_scale(const char* block) const { return has_scale(std::string_view{block}); }
 
    double get_scale(const std::string& block) const { return get_scale(std::string_view{block}); }
    double get_scale(const char* block) const { return get_scale(std::string_view{block}); }
 
    
private:
    
    bool has_scale(std::string_view block) const;
 
    double get_scale(std::string_view block) const;
    
    bool contains(std::string_view name) const;
 
    void emplace(std::string_view name, std::shared_ptr<Block> blk) {
        emplace(BlockName(std::string(name)), std::move(blk));
    }
 
    std::shared_ptr<Block>& at(std::string_view name);
 
    const std::shared_ptr<Block>& at(std::string_view name) const;
    
    bool has_param(std::string_view block, const LhaID& id) const;
 
    scalar_t getValue(std::string_view block, const LhaID& id) const;
 
    void setValue(std::string_view block, const LhaID& id, scalar_t value);
 
    void remove_item(std::string_view block, const LhaID& id);
 
    void erase_block(std::string_view alias_or_key);
    
    static std::unordered_set<std::string> norm_aliases(const BlockName& n);
 
    static std::string choose_key(const std::unordered_set<std::string>& aliases_norm);
 
    static std::string normalize(std::string_view s);
    
    std::string key_for(std::string_view alias) const;
 
    std::string key_for(const BlockName& name) const;
 
    std::string key_for(const std::string& name) const;
    
    std::string resolve_key(std::string_view name) const;
 
    std::string resolve_key(const BlockName& name) const;
 
    void merge_name_into_key(const std::string& key, const BlockName& name);
    
    std::unordered_map<std::string, std::string> alias_to_key_;
 
    std::unordered_map<std::string, BlockName> key_to_name_;
};
 
#endif