RuleSet.cpp

Go to the documentation of this file.

#include "kids/RuleSet.h"
 
#include <map>
#include <string>
 
#include "kids/RuleEvaluator.h"
#include "kids/concat.h"
#include "kids/fmt.h"
 
namespace PROJECT_NS {
 
std::vector<std::shared_ptr<RuleSet>>& RuleSet::getRuleSets() {
    static std::vector<std::shared_ptr<RuleSet>> _GLOBAL;
    return _GLOBAL;
}
 
void RuleSet::registerRulesInRuleSet(std::shared_ptr<RuleEvaluator>& exprRule) {
    auto& expression_ios = getRuleSets();
    for (auto it = expression_ios.begin(); it != expression_ios.end(); ++it) {
        if (exprRule->save == (*it)->unique_name) {
            (*it)->rules.push_back(exprRule);
            (*it)->appendHeader(exprRule);
            return;
        }
    }
    expression_ios.push_back(std::shared_ptr<RuleSet>(new RuleSet(exprRule)));
}
 
void RuleSet::registerRules(std::shared_ptr<RuleEvaluator>& exprRule) {
    rules.push_back(exprRule);
    RuleSet::registerRulesInRuleSet(exprRule);
}
 
RuleSet::RuleSet(std::shared_ptr<RuleEvaluator>& expr_rule) {
    unique_name      = expr_rule->save;
    header           = "";
    totalFrameNumber = expr_rule->totalFrameNumber;
    rules.push_back(expr_rule);
    appendHeader(expr_rule);
}
 
void RuleSet::flush_all(const std::string& path, int level) {
    auto& expression_ios = getRuleSets();
    for (auto& io : expression_ios) io->flush(path, level);
}
 
void RuleSet::flush(const std::string& path, int level) {
    std::ofstream ofs(utils::concat(path, "/", unique_name));
    ofs << header << "\n";
    for (int iframe = 0; iframe < totalFrameNumber; ++iframe) {
        for (auto& r : rules) {
            std::shared_ptr<VariableDescriptor> resvar;
            switch (level) {
                case 0: {
                    resvar = r->result;
                    break;
                }
                case 1: {
                    resvar = r->collect;
                    break;
                }
                case 2: {
                    resvar = r->reduced;
                    break;
                }
            }
            r->writeTo(ofs, resvar->dataPointer, iframe);
        }
        ofs << "\n";
    }
    ofs.close();
}
 
void RuleSet::appendHeader(std::shared_ptr<RuleEvaluator>& expr_rule) {
    auto&             res = expr_rule->result;
    std::stringstream ss;
    switch (res->dataType) {
        case kids_real_type: {
            for (int i = 0; i < expr_rule->totalTermNumber; ++i) {  //
                if (expr_rule->totalTermNumber == 1) {
                    ss << FMT(8) << res->name;
                } else {
                    ss << FMT(8) << utils::concat(res->name, i);
                }
            }
            break;
        }
        case kids_complex_type: {
            for (int i = 0; i < expr_rule->totalTermNumber; ++i) {
                if (expr_rule->totalTermNumber == 1) {
                    ss << FMT(8) << utils::concat("R", res->name)  //
                       << FMT(8) << utils::concat("I", res->name);
                } else {
                    ss << FMT(8) << utils::concat("R", res->name, i)  //
                       << FMT(8) << utils::concat("I", res->name, i);
                }
            }
            break;
        }
    }
    header += ss.str();
}
 
std::vector<std::shared_ptr<RuleEvaluator>>& RuleSet::getRules() { return rules; }
 
Result RuleSet::getResult(int level) {
    Result                              res{};
    std::shared_ptr<VariableDescriptor> resvar;
    for (auto& r : rules) {
        switch (level) {
            case 0: {
                resvar = r->result;
                break;
            }
            case 1: {
                resvar = r->collect;
                break;
            }
            case 2: {
                resvar = r->reduced;
                break;
            }
        }
        std::string key = utils::concat(resvar->field, ".", resvar->name);
        res._data.push_back(std::make_tuple(key,                    //
                                            resvar->dataPointer,    //
                                            resvar->dataType,       //
                                            resvar->shape->size(),  //
                                            totalFrameNumber        //
                                            ));
    }
    return res;
}
 
};  // namespace PROJECT_NS