ConfigTool.cxx

Go to the documentation of this file.

//***************************************************************************************
//***************************************************************************************
 
#include "NAGASH/ConfigTool.h"
 
using namespace NAGASH;
using namespace std;
 
// new version
// use std::regex to match token
// also enable using # as a start of comment
 
ConfigTool::ConfigTool(const char *inputfilename)
{
    msg = std::make_shared<MSGTool>();
 
    msg->StartTitle("ConfigTool::ReadConfigFromFile");
    ReadConfigFromFile(inputfilename);
    msg->EndTitle();
 
    // Config MSGTool
    bool doexistmsg = false;
    bool doexistfocus = false;
    bool doexistlog = false;
    msg->OutputLevel = MSGLevel::SILENT;
    auto msglevel = GetPar<TString>("MSGLevel", &doexistmsg);
    auto FocusName = GetPar<TString>("FocusRegionName", &doexistfocus);
    auto LogName = GetPar<TString>("LogFileName", &doexistlog);
    bool docreatelog = GetPar<bool>("CreateLog");
    bool doopenlog = GetPar<bool>("OpenLog");
    msg->OutputLevel = MSGLevel::INFO;
    MSGLevel level = MSGLevel::INFO;
    if (doexistmsg)
    {
        if (msglevel == "SILENT")
            level = MSGLevel::SILENT;
        if (msglevel == "FATAL")
            level = MSGLevel::FATAL;
        if (msglevel == "ERROR")
            level = MSGLevel::ERROR;
        if (msglevel == "WARNING")
            level = MSGLevel::WARNING;
        if (msglevel == "INFO")
            level = MSGLevel::INFO;
        if (msglevel == "DEBUG")
            level = MSGLevel::DEBUG;
        if (msglevel == "FOCUS")
            level = MSGLevel::FOCUS;
 
        if (doexistfocus)
            msg.reset(new MSGTool(level, FocusName));
        else
            msg.reset(new MSGTool(level));
    }
 
    if (doexistlog)
    {
        if (docreatelog)
            msg->CreateLog(LogName);
        if (doopenlog)
            msg->OpenLog(LogName);
    }
    else if (docreatelog || doopenlog)
    {
        MSGUser()->StartTitle("ConfigTool::SetMSG");
        MSGUser()->MSG(MSGLevel::WARNING, "LogFileName not set, will print message to console");
        MSGUser()->EndTitle();
    }
}
 
void ConfigTool::ReadConfigFromFile(const TString &filename)
{
    std::ifstream infile;
    infile.open(filename, std::ios::in);
    if (!infile.is_open())
    {
        msg->MSG_ERROR("config file ", filename, " does not exist");
        return;
    }
 
    // md5 check sum, in order to prevent same file from being included twice
    {
        auto md5sum = Exec(TString("md5sum " + filename).Data());
        std::regex md5_regex("([0-9a-f]{32})");
        auto match = std::sregex_iterator(md5sum.begin(), md5sum.end(), md5_regex);
 
        if (std::find(InputMD5Sum.begin(), InputMD5Sum.end(), match->str()) != InputMD5Sum.end())
        {
            msg->MSG_ERROR("input file ", filename, " has already been read");
            return;
        }
        else
            InputMD5Sum.emplace_back(match->str());
    }
 
    std::string line;
    while (std::getline(infile, line))
    {
        // remove comment
        auto commentstart = line.find("#");
        if (commentstart != std::string::npos)
        {
            line.erase(commentstart, line.size());
        }
 
        // use regex to match token
        // std::regex word_regex("([\\+-/A-Za-z0-9_\\.]+)");
        std::regex word_regex("([^\\s]+)");
        auto words_begin = std::sregex_iterator(line.begin(), line.end(), word_regex);
        auto words_end = std::sregex_iterator();
        std::vector<std::string> matched_words;
        for (auto i = words_begin; i != words_end; ++i)
        {
            matched_words.push_back((*i).str());
        }
 
        if (matched_words.size() >= 2)
        {
            if (matched_words[0] == "include")
            {
                for (uint32_t i = 1; i < matched_words.size(); i++)
                    ReadConfigFromFile(matched_words[i]);
 
                continue;
            }
        }
 
        if (matched_words.size() >= 3)
        {
            std::string type = matched_words[0];
            std::string name = matched_words[1];
 
            if (type == "int")
            {
                std::istringstream record(matched_words[2]);
                int temp_int;
                record >> temp_int;
                BookParFile<int>(name, temp_int);
            }
            else if (type == "intvec")
            {
                std::vector<int> temp_intvec;
                for (uint32_t i = 2; i < matched_words.size(); i++)
                {
                    std::istringstream record(matched_words[i]);
                    int temp_int;
                    record >> temp_int;
                    temp_intvec.push_back(temp_int);
                }
                BookParFile<std::vector<int>>(name, temp_intvec);
            }
            else if (type == "double")
            {
                std::istringstream record(matched_words[2]);
                double temp_double;
                record >> temp_double;
                BookParFile<double>(name, temp_double);
            }
            else if (type == "doublevec")
            {
                std::vector<double> temp_doublevec;
                for (uint64_t i = 2; i < matched_words.size(); i++)
                {
                    std::istringstream record(matched_words[i]);
                    double temp_double;
                    record >> temp_double;
                    temp_doublevec.push_back(temp_double);
                }
                BookParFile<std::vector<double>>(name, temp_doublevec);
            }
            else if (type == "long")
            {
                std::istringstream record(matched_words[2]);
                long temp_long;
                record >> temp_long;
                BookParFile<long>(name, temp_long);
            }
            else if (type == "longvec")
            {
                std::vector<long> temp_longvec;
                for (uint64_t i = 2; i < matched_words.size(); i++)
                {
                    std::istringstream record(matched_words[i]);
                    long temp_long;
                    record >> temp_long;
                    temp_longvec.push_back(temp_long);
                }
                BookParFile<std::vector<long>>(name, temp_longvec);
            }
            else if (type == "bool")
            {
                std::istringstream record(matched_words[2]);
                bool temp_bool;
                record >> temp_bool;
                BookParFile<bool>(name, temp_bool);
            }
            else if (type == "boolvec")
            {
                std::vector<bool> temp_boolvec;
                for (uint64_t i = 2; i < matched_words.size(); i++)
                {
                    std::istringstream record(matched_words[i]);
                    bool temp_bool;
                    record >> temp_bool;
                    temp_boolvec.push_back(temp_bool);
                }
                BookParFile<std::vector<bool>>(name, temp_boolvec);
            }
            else if (type == "string")
            {
                std::istringstream record(matched_words[2]);
                TString temp_string;
                record >> temp_string;
                BookParFile<TString>(name, temp_string);
            }
            else if (type == "stringvec")
            {
                std::vector<TString> temp_stringvec;
                for (uint64_t i = 2; i < matched_words.size(); i++)
                {
                    std::istringstream record(matched_words[i]);
                    TString temp_string;
                    record >> temp_string;
                    temp_stringvec.push_back(temp_string);
                }
                BookParFile<std::vector<TString>>(name, temp_stringvec);
            }
            else
            {
                MSGUser()->MSG_WARNING("parameter ", name, " type ", type, " is not allowed");
            }
        }
    }
 
    infile.close();
}
 
std::string ConfigTool::Exec(std::string command)
{
    char buffer[128];
    std::string result = "";
 
    // Open pipe to file
    FILE *pipe = popen(command.c_str(), "r");
    if (!pipe)
        return "popen failed!";
 
    // read till end of process:
    while (!feof(pipe))
    {
        // use buffer to read and add to result
        if (fgets(buffer, 128, pipe) != NULL)
            result += buffer;
    }
 
    pclose(pipe);
    return result;
}