func_bundle.hh

Go to the documentation of this file.

#ifndef UTOPIA_MODELS_ENVIRONMENT_FUNCBUNDLE_HH
#define UTOPIA_MODELS_ENVIRONMENT_FUNCBUNDLE_HH
 
namespace Utopia::Models::Environment {
namespace FuncBundle {
 
 
template<typename Func, typename Time>
struct FuncBundle {
    std::string name;       
    Func func;              
    bool invoke_at_initialization;  
    bool invoke_always;     
    std::set<Time> times;   
 
    FuncBundle(std::string name, Func func,
            bool invoke_at_initialization = true, bool invoke_always = true,
            std::set<Time> times = {})
    :
        name(name),
        func(func),
        invoke_at_initialization(invoke_at_initialization),
        invoke_always(invoke_always),
        times(times)
    {}
};
 
 
template<typename Func, typename Time>
struct ParamFuncBundle : FuncBundle<Func, Time> {
    std::string param_name;
 
    ParamFuncBundle(std::string name, Func func, std::string param_name,
            bool invoke_at_initialization = true, bool invoke_always = true,
            std::set<Time> times = {})
    :
        FuncBundle<Func, Time>(name, func, invoke_at_initialization,
                invoke_always, times),
        param_name(param_name)
    {}
 
    ParamFuncBundle(std::string name, Func func, std::string param_name,
            std::tuple<bool, bool, std::set<Time>> invoke_times_tuple)
    :
        ParamFuncBundle<Func, Time>(name, func, param_name,
                std::get<0>(invoke_times_tuple),
                std::get<1>(invoke_times_tuple),
                std::get<2>(invoke_times_tuple))
    {}
};
 
 
template<typename RuleFunc, typename Time, typename CellContainer>
struct RuleFuncBundle : FuncBundle<RuleFunc, Time> {
    Update update;
 
    // Select a subset of cells
    bool fix_selection;
    CellContainer cell_selection;
    DataIO::Config select_cfg;
 
    RuleFuncBundle(std::string name, RuleFunc func,
            Update update = Update::sync, bool invoke_at_initialization = true,
            bool invoke_always = true, std::set<Time> times = {},
            bool fix_selection = false,
            const CellContainer& cell_selection = {},
            const DataIO::Config& select_cfg = {})
    :
        FuncBundle<RuleFunc, Time>(name, func, invoke_at_initialization,
                invoke_always, times),
        update(update),
        fix_selection(fix_selection),
        cell_selection(cell_selection),
        select_cfg(select_cfg)
    { }
 
    RuleFuncBundle(std::string name, RuleFunc func, Update update,
            bool invoke_at_initialization,
            std::pair<bool, std::set<Time>> times_pair,
            std::tuple<bool, CellContainer, DataIO::Config> select_tuple)
    :
        RuleFuncBundle<RuleFunc, Time, CellContainer>(name, func, update,
                invoke_at_initialization, times_pair.first, times_pair.second,
                std::get<bool>(select_tuple),
                std::get<CellContainer>(select_tuple),
                std::get<DataIO::Config>(select_tuple))
    {}
};
 
// End group Environment
} // namespace FuncBundle
} // namespace Utopia::Models::Environment
 
#endif