rules-bones.hpp

Go to the documentation of this file.

#ifndef BARRY_RULES_BONES_HPP
#define BARRY_RULES_BONES_HPP 1
 
template <typename Array_Type, typename Data_Type>
bool rule_fun_default(const Array_Type * array, size_t i, size_t j, Data_Type * dat) {
    return false;
}
 
template<typename Array_Type = BArray<>, typename Data_Type = bool>
class Rule {
    
private:
    Rule_fun_type<Array_Type,Data_Type> fun;
    Data_Type dat;
    
    std::string  name = "";
    std::string  desc = "";
    
public:
 
    Rule() : fun(rule_fun_default<Array_Type,Data_Type>) {};
    Rule(
        Rule_fun_type<Array_Type,Data_Type> fun_,
        Data_Type dat_,
        std::string name_        = "",   
        std::string desc_        = ""
        ) : fun(fun_), dat(dat_), name(name_), desc(desc_) {};
 
    ~Rule() {};
 
    Data_Type & D(); 
    
    bool operator()(const Array_Type & a, size_t i, size_t j);
 
    std::string & get_name();
    std::string & get_description();
 
    std::string get_name() const;
    std::string get_description() const;
    
};
 
template<typename Array_Type, typename Data_Type>
class Rules {
 
private:
    std::vector< Rule<Array_Type,Data_Type> > data;
    
public:
    Rules() {};
 
    Rules(const Rules<Array_Type,Data_Type> & rules_);
    Rules<Array_Type,Data_Type> operator=(const Rules<Array_Type,Data_Type> & rules_);
 
    ~Rules() {};
 
    size_t size() const noexcept {
        return data.size();
    };
    
    void add_rule(Rule<Array_Type, Data_Type> rule);
    void add_rule(
        Rule_fun_type<Array_Type,Data_Type> rule_,
        Data_Type data_,
        std::string name_ = "",
        std::string description_ = ""
    );
 
    bool operator()(const Array_Type & a, size_t i, size_t j);
    
    void get_seq(
        const Array_Type & a,
        std::vector< size_t > * free,
        std::vector< size_t > * locked = nullptr
    );
 
    std::vector< std::string > get_names() const;
    std::vector< std::string > get_descriptions() const;
 
    // Iterator
    typename std::vector< Rule<Array_Type,Data_Type> >::iterator begin() {
        return data.begin();
    };
    typename std::vector< Rule<Array_Type,Data_Type> >::iterator end() {
        return data.end();
    };
    
};
 
 
#endif