TRestMetadata.cxx

/*************************************************************************
 * This file is part of the REST software framework.                     *
 *                                                                       *
 * Copyright (C) 2016 GIFNA/TREX (University of Zaragoza)                *
 * For more information see http://gifna.unizar.es/trex                  *
 *                                                                       *
 * REST is free software: you can redistribute it and/or modify          *
 * it under the terms of the GNU General Public License as published by  *
 * the Free Software Foundation, either version 3 of the License, or     *
 * (at your option) any later version.                                   *
 *                                                                       *
 * REST is distributed in the hope that it will be useful,               *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the          *
 * GNU General Public License for more details.                          *
 *                                                                       *
 * You should have a copy of the GNU General Public License along with   *
 * REST in $REST_PATH/LICENSE.                                           *
 * If not, see http://www.gnu.org/licenses/.                             *
 * For the list of contributors see $REST_PATH/CREDITS.                  *
 *************************************************************************/
 
 
#include "TRestMetadata.h"
 
#include <TFormula.h>
#include <TMath.h>
#include <TStreamerInfo.h>
 
#include <iomanip>
 
#include "TRestDataBase.h"
 
// implementation of version methods in namespace rest_version
/*
namespace REST_VersionGlob {
       inline TString GetRESTVersion() const { return REST_RELEASE; }
       inline int GetRESTVersionCode() const { return ConvertVersionCode(REST_RELEASE); }
}
*/
using namespace std;
using namespace REST_Units;
using namespace REST_Physics;
 
// We introduce the gases file here.
// But, should we have a corner somewhere to define hard-coded globals?
// nkx, 20200228: We now define the global data servers in database file
// const char* gasesFile = "https://sultan.unizar.es/gasFiles/gases.rml";
 
map<string, string> TRestMetadata_UpdatedConfigFile;
 
ClassImp(TRestMetadata);
TRestMetadata::TRestMetadata() : RESTendl(this) {
    fStore = true;
    fElementGlobal = nullptr;
    fElement = nullptr;
    fVerboseLevel = gVerbose;
    fVariables.clear();
    fConstants.clear();
    fHostmgr = nullptr;
 
    fConfigFileName = "null";
    configBuffer = "";
    RESTMetadata.setlength(100);
 
#ifdef WIN32
    fOfficialRelease = true;
    fCleanState = true;
#else
    if (TRestTools::Execute("rest-config --release") == "Yes") fOfficialRelease = true;
    if (TRestTools::Execute("rest-config --clean") == "Yes") fCleanState = true;
#endif
}
 
TRestMetadata::TRestMetadata(const TRestMetadata&) : RESTendl(this) {
    fStore = true;
    fElementGlobal = nullptr;
    fElement = nullptr;
    fVerboseLevel = gVerbose;
    fVariables.clear();
    fConstants.clear();
    fHostmgr = nullptr;
 
    fConfigFileName = "null";
    configBuffer = "";
    RESTMetadata.setlength(100);
 
#ifdef WIN32
    fOfficialRelease = true;
    fCleanState = true;
#else
    if (TRestTools::Execute("rest-config --release") == "Yes") fOfficialRelease = true;
    if (TRestTools::Execute("rest-config --clean") == "Yes") fCleanState = true;
#endif
}
 
TRestMetadata::TRestMetadata(const char* configFilename) : RESTendl(this) {
    fStore = true;
    fElementGlobal = nullptr;
    fElement = nullptr;
    fVerboseLevel = gVerbose;
    fVariables.clear();
    fConstants.clear();
    fHostmgr = nullptr;
 
    fConfigFileName = configFilename;
    configBuffer = "";
    RESTMetadata.setlength(100);
 
#ifdef WIN32
    fOfficialRelease = true;
    fCleanState = true;
#else
    if (TRestTools::Execute("rest-config --release") == "Yes") fOfficialRelease = true;
    if (TRestTools::Execute("rest-config --clean") == "Yes") fCleanState = true;
#endif
}
 
TRestMetadata::~TRestMetadata() {
    delete fElementGlobal;
    delete fElement;
}
 
Int_t TRestMetadata::LoadConfigFromFile(const string& configFilename, const string& sectionName) {
    fConfigFileName = configFilename;
 
    const string thisSectionName = sectionName.empty() ? this->ClassName() : sectionName;
 
    if (!TRestTools::fileExists(fConfigFileName)) fConfigFileName = SearchFile(fConfigFileName);
 
    if (TRestTools::fileExists(fConfigFileName)) {
        // find the xml section corresponding to the sectionName
        TiXmlElement* Sectional = GetElementFromFile(fConfigFileName, thisSectionName);
        if (Sectional == nullptr) {
            RESTError << "cannot find xml section \"" << ClassName() << "\" with name \"" << sectionName
                      << "\"" << RESTendl;
            RESTError << "in config file: " << fConfigFileName << RESTendl;
            exit(1);
        }
 
        // find the "globals" section. Multiple sections are supported.
        TiXmlElement* rootEle = GetElementFromFile(fConfigFileName);
        TiXmlElement* Global = GetElement("globals", rootEle);
        if (Global != nullptr) ReadElement(Global);
        if (Global != nullptr && Global->NextSiblingElement("globals") != nullptr) {
            TiXmlElement* ele = Global->NextSiblingElement("globals");
            if (ele != nullptr) ReadElement(ele);
            while (ele != nullptr) {
                TiXmlElement* e = ele->FirstChildElement();
                while (e != nullptr) {
                    Global->InsertEndChild(*e);
                    e = e->NextSiblingElement();
                }
                ele = ele->NextSiblingElement("globals");
            }
        }
 
        // call the real loading method
        int result = LoadConfigFromElement(Sectional, Global, {});
        delete Sectional;
        delete rootEle;
        return result;
    } else {
        RESTError << "Filename: " << fConfigFileName << RESTendl;
        RESTError << "Config File does not exist. Right path/filename?" << RESTendl;
        GetChar();
        return -1;
    }
 
    // find the xml section corresponding to the sectionName
    TiXmlElement* sectional = GetElementFromFile(fConfigFileName, thisSectionName);
    if (sectional == nullptr) {
        RESTError << "cannot find xml section \"" << ClassName() << "\" with name \"" << thisSectionName
                  << "\"" << RESTendl;
        RESTError << "in config file: " << fConfigFileName << RESTendl;
        exit(1);
    }
 
    // find the "globals" section. Multiple sections are supported.
    TiXmlElement* rootEle = GetElementFromFile(fConfigFileName);
    TiXmlElement* global = GetElement("globals", rootEle);
    if (global != nullptr) ReadElement(global);
    if (global != nullptr && global->NextSiblingElement("globals") != nullptr) {
        TiXmlElement* ele = global->NextSiblingElement("globals");
        if (ele != nullptr) ReadElement(ele);
        while (ele != nullptr) {
            TiXmlElement* e = ele->FirstChildElement();
            while (e != nullptr) {
                global->InsertEndChild(*e);
                e = e->NextSiblingElement();
            }
            ele = ele->NextSiblingElement("globals");
        }
    }
 
    // call the real loading method
    int result = LoadConfigFromElement(sectional, global, {});
    delete sectional;
    delete rootEle;
    return result;
}
 
Int_t TRestMetadata::LoadConfigFromElement(TiXmlElement* eSectional, TiXmlElement* eGlobal,
                                           map<string, string> envs) {
    Initialize();
    TiXmlElement* theElement;
    if (eSectional != nullptr && eGlobal != nullptr) {
        // Sectional and global elements are first combined.
        theElement = (TiXmlElement*)eSectional->Clone();
        TiXmlElement* echild = eGlobal->FirstChildElement();
        while (echild != nullptr) {
            theElement->LinkEndChild(echild->Clone());
            echild = echild->NextSiblingElement();
        }
        // for (int i = 0; i < eEnv.size(); i++) {
        //    theElement->LinkEndChild(eEnv[i]->Clone());
        //}
    } else if (eSectional != nullptr) {
        theElement = (TiXmlElement*)eSectional->Clone();
    } else if (eGlobal != nullptr) {
        theElement = (TiXmlElement*)eGlobal->Clone();
    } else {
        return 0;
    }
    fElement = theElement;
    fElementGlobal = eGlobal ? (TiXmlElement*)eGlobal->Clone() : nullptr;
    fVariables = envs;
 
    int result = LoadSectionMetadata();
    if (result == 0) InitFromConfigFile();
    RESTDebug << ClassName() << " has finished preparing config data" << RESTendl;
    return result;
}
 
Int_t TRestMetadata::LoadConfigFromBuffer() {
    if (configBuffer != "") {
        fElement = StringToElement(configBuffer);
        configBuffer = "";
        InitFromRootFile();
        return 0;
    }
    return -1;
}
 
TRestMetadata* TRestMetadata::InstantiateChildMetadata(int index, std::string pattern) {
    int count = 0;
    auto paraele = fElement->FirstChildElement();
    while (paraele != nullptr) {
        std::string xmlChild = paraele->Value();
        if (xmlChild.find("TRest") == 0) {
            if (pattern == "" || xmlChild.find(pattern) != string::npos) {
                if (count == index) {
                    TClass* c = TClass::GetClass(xmlChild.c_str());
                    if (c)  // this means that the metadata class was found
                    {
                        TRestMetadata* md = (TRestMetadata*)c->New();
                        if (!md) return nullptr;
                        md->SetConfigFile(fConfigFileName);
                        TiXmlElement* rootEle = GetElementFromFile(fConfigFileName);
                        TiXmlElement* Global = GetElement("globals", rootEle);
                        md->LoadConfigFromElement(paraele, Global, {});
                        md->Initialize();
                        return md;
                    }
                }
                count++;
            }
        }
        paraele = paraele->NextSiblingElement();
    }
    return nullptr;
}
 
TRestMetadata* TRestMetadata::InstantiateChildMetadata(std::string pattern, std::string name) {
    auto paraele = fElement->FirstChildElement();
    while (paraele != nullptr) {
        std::string xmlChild = paraele->Value();
        if (xmlChild.find("TRest") == 0) {
            if (pattern.empty() || xmlChild.find(pattern) != string::npos) {
                if (name.empty() || (!name.empty() && name == (string)paraele->Attribute("name"))) {
                    TClass* c = TClass::GetClass(xmlChild.c_str());
                    if (c)  // this means we have the metadata class was found
                    {
                        TRestMetadata* md = (TRestMetadata*)c->New();
                        TiXmlElement* rootEle = GetElementFromFile(fConfigFileName);
                        TiXmlElement* Global = GetElement("globals", rootEle);
                        md->LoadConfigFromElement(paraele, Global, {});
                        md->Initialize();
                        return md;
                    }
                }
            }
        }
        paraele = paraele->NextSiblingElement();
    }
    return nullptr;
}
 
Int_t TRestMetadata::LoadSectionMetadata() {
    // get debug level
    string debugStr = GetParameter("verboseLevel", ToString(static_cast<int>(fVerboseLevel)));
    fVerboseLevel = StringToVerboseLevel(debugStr);
 
    RESTDebug << "Loading Config for : " << this->ClassName() << RESTendl;
 
    // set env first from global section
    if (fElementGlobal != nullptr) {
        TiXmlElement* e = fElementGlobal->FirstChildElement();
        while (e != nullptr) {
            ReplaceElementAttributes(e);
            ReadEnvInElement(e);
            e = e->NextSiblingElement();
        }
    }
 
    // then from local section
    TiXmlElement* e = fElement->FirstChildElement();
    while (e != nullptr) {
        ReplaceElementAttributes(e);
        ReadEnvInElement(e);
        e = e->NextSiblingElement();
    }
 
    // look through the elements and expand for, include, etc. structures
    ReadElement(fElement);
 
    // get debug level again in case it is defined in the included file
    debugStr = GetParameter("verboseLevel", ToString(static_cast<int>(fVerboseLevel)));
    fVerboseLevel = StringToVerboseLevel(debugStr);
 
    // fill the general metadata info: name, title, fstore
    this->SetName(GetParameter("name", "default" + string(this->ClassName())).c_str());
    this->SetTitle(GetParameter("title", "Default " + string(this->ClassName())).c_str());
    this->SetSectionName(this->ClassName());
 
    fStore = StringToBool(GetParameter("store", to_string(true)));
 
    return 0;
}
 
TiXmlElement* TRestMetadata::ReplaceElementAttributes(TiXmlElement* e) {
    if (e == nullptr) return nullptr;
 
    RESTDebug << "Entering ... TRestMetadata::ReplaceElementAttributes" << RESTendl;
 
    std::string parName = "";
    TiXmlAttribute* attr = e->FirstAttribute();
    while (attr != nullptr) {
        const char* val = attr->Value();
        const char* name = attr->Name();
        RESTDebug << "Element name : " << name << " value : " << val << RESTendl;
 
        string newVal = val != nullptr ? val : "";
        newVal = ReplaceVariables(newVal);
 
        // for name attribute, don't replace constants
        if (strcmp(name, "name") != 0) newVal = ReplaceConstants(newVal);
 
        e->SetAttribute(name, ReplaceMathematicalExpressions(newVal));
 
        attr = attr->Next();
    }
 
    return e;
}
 
void TRestMetadata::ReadEnvInElement(TiXmlElement* e, bool overwrite) {
    if (e == nullptr) return;
 
    const char* name = e->Attribute("name");
    if (name == nullptr) return;
    const char* value = e->Attribute("value");
    if (value == nullptr) return;
 
    if ((string)e->Value() == "variable") {
        // if overwrite is false, try to replace the value from system env.
        const char* overwritesysenv = e->Attribute("overwrite");
        if (overwritesysenv == nullptr) overwritesysenv = "false";
        if (!StringToBool(overwritesysenv)) {
            char* sysenv = getenv(name);
            if (sysenv != nullptr) value = sysenv;
        }
        if (!overwrite && fVariables.count(name) > 0) return;
        fVariables[name] = value;
    } else if ((string)e->Value() == "constant") {
        if (!overwrite && fVariables.count(name) > 0) return;
        fConstants[name] = value;
    } else if ((string)e->Value() == "myParameter") {
        RESTWarning << "myParameter is obsolete now! use \"constant\" instead" << RESTendl;
        if (!overwrite && fVariables.count(name) > 0) return;
        fConstants[name] = value;
    }
}
 
void TRestMetadata::ReadElement(TiXmlElement* e, bool recursive) {
    RESTDebug << ClassName() << "::ReadElement(<" << e->Value() << ")" << RESTendl;
    if (e == nullptr) return;
 
    ReplaceElementAttributes(e);
    ReadEnvInElement(e);
 
    if ((string)e->Value() == "for") {
        ExpandForLoops(e, {});
    } else if (e->Attribute("file") != nullptr) {
        ExpandIncludeFile(e);
    } else if ((string)e->Value() == "if") {
        ExpandIfSections(e);
    } else if (e->FirstChildElement() != nullptr) {
        TiXmlElement* contentelement = e->FirstChildElement();
        // we won't expand child TRestXXX sections unless forced recursive. The expansion of
        // these sections will be executed individually by the corresponding TRestXXX class
        while (contentelement != nullptr) {
            TiXmlElement* nxt = contentelement->NextSiblingElement();
            if (recursive || ((string)contentelement->Value()).find("TRest") == string::npos) {
                RESTDebug << "into child element \"" << contentelement->Value() << "\" of \"" << e->Value()
                          << "\"" << RESTendl;
                ReadElement(contentelement, recursive);
            } else {
                RESTDebug << "skipping child element \"" << contentelement->Value() << "\" of \""
                          << e->Value() << "\"" << RESTendl;
            }
            contentelement = nxt;
        }
    }
}
 
void TRestMetadata::ExpandIfSections(TiXmlElement* e) {
    if (e == nullptr) return;
    if ((string)e->Value() != "if") return;
 
    const char* evaluate = e->Attribute("evaluate");
    const char* condition = e->Attribute("condition");
 
    if (condition == nullptr || string(condition).find_first_of("=!<>") == string::npos) {
        RESTWarning << "Invalid \"IF\" structure!" << RESTendl;
        return;
    }
 
    int p1 = string(condition).find_first_of("=!<>");
    int p2 = string(condition).find_first_not_of("=!<>", p1);
 
    string v1 = "";
    bool matches = false;
    if (evaluate != nullptr) {
        v1 = TRestTools::Execute(evaluate);
    } else if (p1 > 0) {
        v1 = string(condition).substr(0, p1);
    } else {
        RESTWarning << "Invalid \"IF\" structure!" << RESTendl;
        return;
    }
 
    string con = string(condition).substr(p1, p2 - p1);
    string v2 = string(condition).substr(p2, -1);
 
    if (con == "==") {
        if (isANumber(v1) && isANumber(v2)) {
            if (atof(v1.c_str()) == atof(v2.c_str())) matches = true;
        } else {
            if (v1 == v2) matches = true;
        }
    } else if (con == "!=") {
        if (isANumber(v1) && isANumber(v2)) {
            if (atof(v1.c_str()) != atof(v2.c_str())) matches = true;
        } else {
            if (v1 != v2) matches = true;
        }
    } else if (con == ">") {
        if (isANumber(v1) && isANumber(v2)) {
            if (atof(v1.c_str()) > atof(v2.c_str())) matches = true;
        } else {
            if (v1 > v2) matches = true;
        }
    } else if (con == "<") {
        if (isANumber(v1) && isANumber(v2)) {
            if (atof(v1.c_str()) < atof(v2.c_str())) matches = true;
        } else {
            if (v1 < v2) matches = true;
        }
    } else if (con == ">=") {
        if (isANumber(v1) && isANumber(v2)) {
            if (atof(v1.c_str()) >= atof(v2.c_str())) matches = true;
        } else {
            if (v1 >= v2) matches = true;
        }
    } else if (con == "<=") {
        if (isANumber(v1) && isANumber(v2)) {
            if (atof(v1.c_str()) <= atof(v2.c_str())) matches = true;
        } else {
            if (v1 <= v2) matches = true;
        }
    } else {
        RESTWarning << "Invalid \"IF\" structure!" << RESTendl;
        return;
    }
 
    if (matches) {
        TiXmlElement* parele = (TiXmlElement*)e->Parent();
        if (parele == nullptr) return;
        TiXmlElement* contentelement = e->FirstChildElement();
        while (contentelement != nullptr) {
            TiXmlElement* attachedelement = (TiXmlElement*)contentelement->Clone();
            ReadElement(attachedelement, true);
            // RESTDebug << *attachedelement << RESTendl;
            parele->InsertBeforeChild(e, *attachedelement);
            delete attachedelement;
            contentelement = contentelement->NextSiblingElement();
        }
    }
}
 
void TRestMetadata::ExpandForLoopOnce(TiXmlElement* e, const map<string, string>& forLoopVar) {
    if (e == nullptr) {
        return;
    }
 
    TiXmlElement* parele = (TiXmlElement*)e->Parent();
    TiXmlElement* contentelement = e->FirstChildElement();
    while (contentelement != nullptr) {
        if ((string)contentelement->Value() == "for") {
            TiXmlElement* newforloop = (TiXmlElement*)contentelement->Clone();
            // ReplaceElementAttributes(newforloop);
            TiXmlElement* tempnew = (TiXmlElement*)parele->InsertBeforeChild(e, *newforloop);
            delete newforloop;
            newforloop = tempnew;
            ExpandForLoops(newforloop, forLoopVar);
            contentelement = contentelement->NextSiblingElement();
        } else {
            TiXmlElement* attachedelement = (TiXmlElement*)contentelement->Clone();
            ReplaceForLoopVars(attachedelement, forLoopVar);
            ReadElement(attachedelement, true);
            // RESTDebug << *attachedelement << RESTendl;
            parele->InsertBeforeChild(e, *attachedelement);
            delete attachedelement;
            contentelement = contentelement->NextSiblingElement();
        }
    }
}
 
void TRestMetadata::ReplaceForLoopVars(TiXmlElement* e, map<string, string> forLoopVar) {
    if (e == nullptr) return;
 
    RESTDebug << "Entering ... TRestMetadata::ReplaceForLoopVars" << RESTendl;
    std::string parName;
    TiXmlAttribute* attr = e->FirstAttribute();
    while (attr != nullptr) {
        const char* val = attr->Value();
        const char* name = attr->Name();
        RESTDebug << "Attribute name : " << name << " value : " << val << RESTendl;
 
        if (strcmp(name, "name") == 0) parName = (string)val;
 
        // set attribute except name field
        if (strcmp(name, "name") != 0) {
            string outputBuffer = val;
 
            if (outputBuffer.find('[') != string::npos || outputBuffer.find(']') != string::npos) {
                RESTError << "TRestMetadata::ReplaceForLoopVars. Old for-loop construction identified"
                          << RESTendl;
                RESTError << "Please, replace [] variable nomenclature by ${}." << RESTendl;
                exit(1);
            }
 
            // replace variables with mark ${}
            int startPosition = 0;
            int endPosition = 0;
            while ((startPosition = outputBuffer.find("{", endPosition)) != (int)string::npos) {
                endPosition = outputBuffer.find("}", startPosition + 1);
                if (endPosition == (int)string::npos) break;
                if (startPosition >= 1 && outputBuffer[startPosition - 1] == '$')
                    break;  // to prevent replacing ${} mark
 
                string expression = outputBuffer.substr(startPosition + 1, endPosition - startPosition - 1);
 
                int replacePos = startPosition;
                int replaceLen = endPosition - startPosition + 1;
 
                string proenv = forLoopVar.count(expression) > 0 ? forLoopVar[expression] : "";
 
                if (!proenv.empty()) {
                    outputBuffer.replace(replacePos, replaceLen, proenv);
                    endPosition = 0;
                } else {
                    RESTError << this->ClassName() << ", replace for loop env : cannot find \"{" << expression
                              << "}\"" << RESTendl;
                    exit(1);
                }
            }
 
            e->SetAttribute(name, ReplaceMathematicalExpressions(
                                      outputBuffer, 0,
                                      "Please, check parameter name: " + parName + " (ReplaceForLoopVars)")
                                      .c_str());
        }
 
        attr = attr->Next();
    }
}
 
void TRestMetadata::ExpandForLoops(TiXmlElement* e, map<string, string> forloopvar) {
    if (e == nullptr) return;
    if ((string)e->Value() != "for") return;
    RESTDebug << "Entering ... ExpandForLoops" << RESTendl;
    ReplaceElementAttributes(e);
 
    TString varname = TString(e->Attribute("variable"));
    TString varfrom = TString(e->Attribute("from"));
    TString varto = TString(e->Attribute("to"));
    TString varstep = TString(e->Attribute("step"));
    TString varin = TString(e->Attribute("in"));
 
    RESTDebug << "variable: " << varname << " from: " << varfrom << " to: " << varto << " step: " << varstep
              << " in: " << varin << RESTendl;
 
    if ((varin == "") && (varname == "" || varfrom == "" || varto == "")) return;
    if (varstep == "") varstep = "1";
    TiXmlElement* parele = (TiXmlElement*)e->Parent();
    if (parele == nullptr) return;
 
    string _name = (string)varname;
    string _from = (string)varfrom;
    string _to = (string)varto;
    string _step = (string)varstep;
    string _in = (string)varin;
    RESTDebug << "_from: " << _from << " _to: " << _to << " _step: " << _step << RESTendl;
    if (isANumber(_from) && isANumber(_to) && isANumber(_step)) {
        double from = StringToDouble(_from);
        double to = StringToDouble(_to);
        double step = StringToDouble(_step);
 
        RESTDebug << "----expanding for loop----" << RESTendl;
        double i = 0;
        for (i = from; i <= to; i = i + step) {
            forloopvar[_name] = ToString(i);
            fVariables[_name] = ToString(i);
            ExpandForLoopOnce(e, forloopvar);
        }
        parele->RemoveChild(e);
 
        if (fVerboseLevel >= TRestStringOutput::REST_Verbose_Level::REST_Extreme) parele->Print(stdout, 0);
        RESTDebug << "----end of for loop----" << RESTendl;
    } else if (!_in.empty()) {
        vector<string> loopvars = Split(_in, ":");
 
        RESTDebug << "----expanding for loop----" << RESTendl;
        for (const string& loopvar : loopvars) {
            forloopvar[_name] = loopvar;
            fVariables[_name] = loopvar;
            ExpandForLoopOnce(e, forloopvar);
        }
        parele->RemoveChild(e);
 
        if (fVerboseLevel >= TRestStringOutput::REST_Verbose_Level::REST_Extreme) parele->Print(stdout, 0);
        RESTDebug << "----end of for loop----" << RESTendl;
    }
    // variable defined in for loop should be temporal
    fVariables.erase(_name);
}
 
void TRestMetadata::ExpandIncludeFile(TiXmlElement* e) {
    RESTDebug << "Entering ... " << __PRETTY_FUNCTION__ << RESTendl;
    if (e == nullptr) return;
 
    ReplaceElementAttributes(e);
    const char* _filename = e->Attribute("file");
    if (_filename == nullptr) return;
 
    string filename;
    if (string(_filename) == "server" || TRestTools::isURL(_filename)) {
        // Let TRestRun to retrieve data according to run number later-on
 
        // match the database, runNumber=0(default data), type="META_RML", tag=<section name>
        auto url = gDataBase->query_data(DBEntry(0, "META_RML", e->Value())).value;
        if (url.empty()) {
            // don't really understand this "database" code, this just works
            url = _filename;
        }
 
        filename = TRestTools::DownloadRemoteFile(url, true);
    } else {
        filename = SearchFile(_filename);
    }
 
    if (filename.empty()) {
        RESTError << "TRestMetadata::ExpandIncludeFile. Include file \"" << _filename << "\" does not exist!"
                  << RESTendl;
        exit(1);
        return;
    }
    if (!TRestTools::isRootFile(filename))  // root file inclusion is implemented in TRestRun
    {
        RESTDebug << "----expanding include file----" << RESTendl;
        // we find the local element(the element to receive content)
        // and the remote element(the element to provide content)
        TiXmlElement* remoteele = nullptr;
        TiXmlElement* localele = nullptr;
        string type;
        string name;
 
        // condition 1(raw file include):
        //   <TRestXXX name="" .....>
        //     <include file="aaa.rml"/>
        //     ....
        //   </TRestXXX>
        //
        // We will insert all the xml elements in aaa.rml into this section
        if ((string)e->Value() == "include") {
            localele = (TiXmlElement*)e->Parent();
            if (localele == nullptr) return;
            if (localele->Attribute("expanded") == nullptr
                    ? false
                    : ((string)localele->Attribute("expanded") == "true")) {
                RESTDebug << "----already expanded----" << RESTendl;
                return;
            }
 
            remoteele = new TiXmlElement("Config");
 
            TiXmlElement* ele = GetElementFromFile(filename);
            if (ele == nullptr) {
                RESTError << "TRestMetadata::ExpandIncludeFile. No xml elements contained in the include "
                             "file \""
                          << filename << "\"" << RESTendl;
                exit(1);
            }
            while (ele != nullptr) {
                remoteele->InsertEndChild(*ele);
                ele = ele->NextSiblingElement();
            }
 
        }
 
        // condition 2(auto insert):
        //   <TRestXXX file=""/>
        // or
        //   <TRestXXX name="" ... file="aaa.rml" .../>
        // or
        //   <addXXX name="" ... file="aaa.rml" .../>
        // or
        //   <addXXX type="" name="" ... file="aaa.rml" .../>
        //
        // Here TRestXXX will be "type". we will find the corresponding section, and
        // insert all its attributes and child elements into this section. "name"
        // overwrites "type"
        else {
            localele = e;
            if (localele->Attribute("expanded") == nullptr
                    ? false
                    : ((string)localele->Attribute("expanded") == "true")) {
                RESTDebug << "----already expanded----" << RESTendl;
                return;
            }
 
            type = e->Attribute("type") != nullptr ? e->Attribute("type") : e->Value();
            name = localele->Attribute("name") == nullptr ? "" : localele->Attribute("name");
 
            // get the root element
            TiXmlElement* rootele = GetElementFromFile(filename);
            if (rootele == nullptr) {
                RESTError << "TRestMetaddata::ExpandIncludeFile. Include file " << filename
                          << " is of wrong xml format!" << RESTendl;
                exit(1);
                return;
            }
            if ((string)rootele->Value() == type) {
                // if root element in the included file is of given type, directly use
                // it
                remoteele = rootele;
            } else {
                // import env first
                if (type != "globals" && GetElement("globals", rootele) != nullptr) {
                    TiXmlElement* globaldef = GetElement("globals", rootele)->FirstChildElement();
                    while (globaldef != nullptr) {
                        ReadEnvInElement(globaldef, false);
                        globaldef = globaldef->NextSiblingElement();
                    }
                }
 
                // find its child section according to type and name
                if (name != "") {
                    // we find only according to the name
                    vector<TiXmlElement*> eles;
                    TiXmlElement* ele = rootele->FirstChildElement();
                    while (ele != nullptr) {
                        if (ele->Attribute("name") != nullptr && (string)ele->Attribute("name") == name) {
                            eles.push_back(ele);
                        }
                        ele = ele->NextSiblingElement();
                    }
                    // more than 1 element found
                    if (eles.size() > 1) {
                        RESTWarning << "(expand include file): find multiple xml sections with same name!"
                                    << RESTendl;
                        RESTWarning << "Using the first one!" << RESTendl;
                    }
 
                    if (eles.size() > 0) remoteele = (TiXmlElement*)eles[0]->Clone();
                } else if (type != "") {
                    remoteele = (TiXmlElement*)GetElement(type, rootele)->Clone();
                }
 
                if (remoteele == nullptr) {
                    RESTWarning << "Cannot find the needed xml section in "
                                   "include file!"
                                << RESTendl;
                    RESTWarning << "type: \"" << type << "\" , name: \"" << name << "\" . Skipping"
                                << RESTendl;
                    RESTWarning << RESTendl;
                    return;
                }
                delete rootele;
            }
        }
 
        RESTDebug << "Target xml element spotted" << RESTendl;
 
        // begin inserting remote element into local element
        ReadElement(remoteele, true);
        int nattr = 0;
        int nele = 0;
        TiXmlAttribute* attr = remoteele->FirstAttribute();
        while (attr != nullptr) {
            if (localele->Attribute(attr->Name()) == nullptr) {
                localele->SetAttribute(attr->Name(), attr->Value());
                nattr++;
            }
            attr = attr->Next();
        }
        TiXmlElement* ele = remoteele->FirstChildElement();
        while (ele != nullptr) {
            // ReadElement(ele);
            if ((string)ele->Value() != "for") {
                localele->InsertEndChild(*ele);
                nele++;
            }
            ele = ele->NextSiblingElement();
        }
 
        localele->SetAttribute("expanded", "true");
        if (fVerboseLevel >= TRestStringOutput::REST_Verbose_Level::REST_Debug) {
            localele->Print(stdout, 0);
            cout << endl;
        }
        delete remoteele;
        RESTDebug << nattr << " attributes and " << nele << " xml elements added by inclusion" << RESTendl;
        RESTDebug << "----end of expansion file----" << RESTendl;
    }
}
 
string TRestMetadata::GetParameter(std::string parName, TString defaultValue) {
    // first search the parameter in REST args
    if (REST_ARGS.count(parName) != 0) {
        return REST_ARGS[parName];
    }
 
    // then look within local xml element
    string result = GetParameter(parName, fElement);
    if (result != PARAMETER_NOT_FOUND_STR) {
        return result;
    }
 
    return (string)defaultValue;
}
 
string TRestMetadata::GetParameter(std::string parName, TiXmlElement* e, TString defaultValue) {
    if (e == nullptr) {
        RESTDebug << "Element is null" << RESTendl;
        return (string)defaultValue;
    }
    string result = (string)defaultValue;
    // first find in attribute
    if (e->Attribute(parName.c_str()) != nullptr) {
        result = e->Attribute(parName.c_str());
    }
    // then find in child sections/elements
    else {
        TiXmlElement* element = GetElementWithName("parameter", parName, e);
        if (element != nullptr && element->Attribute("value") != nullptr) {
            result = element->Attribute("value");
        } else {
            RESTDebug << ClassName() << ": Parameter : " << parName << " not found!" << RESTendl;
        }
    }
 
    return ReplaceMathematicalExpressions(ReplaceConstants(ReplaceVariables(result)), 0,
                                          "Please, check parameter name: " + parName);
}
 
Double_t TRestMetadata::GetDblParameterWithUnits(std::string parName, TiXmlElement* ele,
                                                 Double_t defaultVal) {
    if (ele == nullptr) return defaultVal;
    pair<string, string> val_unit = GetParameterAndUnits(parName, ele);
    string val = val_unit.first;
    string unit = val_unit.second;
    if (val == PARAMETER_NOT_FOUND_STR) {
        return defaultVal;
    } else {
        Double_t value = StringToDouble(val);
        return REST_Units::ConvertValueToRESTUnits(value, unit);
    }
 
    return defaultVal;
}
 
TVector2 TRestMetadata::Get2DVectorParameterWithUnits(std::string parName, TiXmlElement* ele,
                                                      TVector2 defaultVal) {
    if (ele == nullptr) return defaultVal;
    pair<string, string> val_unit = GetParameterAndUnits(parName, ele);
    string val = val_unit.first;
    string unit = val_unit.second;
    if (val == PARAMETER_NOT_FOUND_STR) {
        return defaultVal;
    } else {
        TVector2 value = StringTo2DVector(val);
        Double_t valueX = REST_Units::ConvertValueToRESTUnits(value.X(), unit);
        Double_t valueY = REST_Units::ConvertValueToRESTUnits(value.Y(), unit);
        return TVector2(valueX, valueY);
    }
 
    return defaultVal;
}
 
TVector3 TRestMetadata::Get3DVectorParameterWithUnits(std::string parName, TiXmlElement* ele,
                                                      TVector3 defaultVal) {
    if (ele == nullptr) return defaultVal;
    pair<string, string> val_unit = GetParameterAndUnits(parName, ele);
    string val = val_unit.first;
    string unit = val_unit.second;
    if (val == PARAMETER_NOT_FOUND_STR) {
        return defaultVal;
    } else {
        TVector3 value = StringTo3DVector(val);
        Double_t valueX = REST_Units::ConvertValueToRESTUnits(value.X(), unit);
        Double_t valueY = REST_Units::ConvertValueToRESTUnits(value.Y(), unit);
        Double_t valueZ = REST_Units::ConvertValueToRESTUnits(value.Z(), unit);
        return TVector3(valueX, valueY, valueZ);
    }
 
    return defaultVal;
}
 
std::string TRestMetadata::GetFieldValue(std::string parName, TiXmlElement* e) {
    if (e == nullptr) {
        RESTDebug << "Element is null" << RESTendl;
        return "Not defined";
    }
    const char* val = e->Attribute(parName.c_str());
    if (val == nullptr) {
        return "Not defined";
    }
 
    string result = (string)val;
    result = Replace(result, " AND ", " && ");
    result = Replace(result, " OR ", " || ");
 
    return result;
}
 
Double_t TRestMetadata::GetDblParameterWithUnits(std::string parName, Double_t defaultVal) {
    pair<string, string> val_unit = GetParameterAndUnits(parName);
    string val = val_unit.first;
    string unit = val_unit.second;
    if (val == PARAMETER_NOT_FOUND_STR) {
        return defaultVal;
    } else {
        Double_t value = StringToDouble(val);
        return REST_Units::ConvertValueToRESTUnits(value, unit);
    }
    return defaultVal;
}
 
TVector2 TRestMetadata::Get2DVectorParameterWithUnits(std::string parName, TVector2 defaultVal) {
    pair<string, string> val_unit = GetParameterAndUnits(parName);
    string val = val_unit.first;
    string unit = val_unit.second;
    if (val == PARAMETER_NOT_FOUND_STR) {
        return defaultVal;
    } else {
        TVector2 value = StringTo2DVector(val);
        Double_t valueX = REST_Units::ConvertValueToRESTUnits(value.X(), unit);
        Double_t valueY = REST_Units::ConvertValueToRESTUnits(value.Y(), unit);
        return TVector2(valueX, valueY);
    }
    return defaultVal;
}
 
TVector3 TRestMetadata::Get3DVectorParameterWithUnits(std::string parName, TVector3 defaultVal) {
    pair<string, string> val_unit = GetParameterAndUnits(parName);
    string val = val_unit.first;
    string unit = val_unit.second;
    if (val == PARAMETER_NOT_FOUND_STR) {
        return defaultVal;
    } else {
        TVector3 value = StringTo3DVector(val);
        Double_t valueX = REST_Units::ConvertValueToRESTUnits(value.X(), unit);
        Double_t valueY = REST_Units::ConvertValueToRESTUnits(value.Y(), unit);
        Double_t valueZ = REST_Units::ConvertValueToRESTUnits(value.Z(), unit);
        return TVector3(valueX, valueY, valueZ);
    }
    return defaultVal;
}
 
TiXmlElement* TRestMetadata::GetElementFromFile(std::string configFilename, std::string NameOrDeclare) {
    TiXmlDocument doc;
    TiXmlElement* rootele;
 
    string filename = configFilename;
    if (TRestMetadata_UpdatedConfigFile.count(filename) > 0)
        filename = TRestMetadata_UpdatedConfigFile[filename];
 
    if (!TRestTools::fileExists(filename)) {
        RESTError << "Config file does not exist. The file is: " << filename << RESTendl;
        exit(1);
    }
 
    if (!doc.LoadFile(filename.c_str())) {
        RESTError << "Failed to load xml file, syntax maybe wrong. The file is: " << filename << RESTendl;
        exit(1);
    }
 
    rootele = doc.RootElement();
    if (rootele == nullptr) {
        RESTError << "The rml file \"" << configFilename << "\" does not contain any valid elements!"
                  << RESTendl;
        exit(1);
    }
    if (NameOrDeclare == "") {
        return (TiXmlElement*)rootele->Clone();
    }
    // search with either name or declare in either root element or sub-root
    // element
    while (rootele != nullptr) {
        if (rootele->Value() != nullptr && (string)rootele->Value() == NameOrDeclare) {
            return (TiXmlElement*)rootele->Clone();
        }
 
        if (rootele->Attribute("name") != nullptr && (string)rootele->Attribute("name") == NameOrDeclare) {
            return (TiXmlElement*)rootele->Clone();
        }
 
        TiXmlElement* etemp = GetElement(NameOrDeclare, rootele);
        if (etemp != nullptr) {
            return (TiXmlElement*)etemp->Clone();
        }
 
        etemp = GetElementWithName("", NameOrDeclare, rootele);
 
        if (etemp != nullptr) {
            return (TiXmlElement*)etemp->Clone();
        }
 
        rootele = rootele->NextSiblingElement();
    }
 
    return nullptr;
    /*ferr << "Cannot find xml element with name \""<< NameOrDeclare <<"\" in rml
    file \"" << configFilename << endl; GetChar(); exit(1);*/
}
 
TiXmlElement* TRestMetadata::GetElement(std::string eleDeclare, TiXmlElement* e) {
    if (e == nullptr) e = fElement;
    return e->FirstChildElement(eleDeclare.c_str());
}
 
TiXmlElement* TRestMetadata::GetNextElement(TiXmlElement* e) {
    if (e == nullptr) return nullptr;
    return e->NextSiblingElement(e->Value());
}
 
TiXmlElement* TRestMetadata::GetElementWithName(std::string eleDeclare, std::string eleName) {
    return GetElementWithName(eleDeclare, eleName, fElement);
}
 
TiXmlElement* TRestMetadata::GetElementWithName(std::string eleDeclare, std::string eleName,
                                                TiXmlElement* e) {
    if (e == nullptr) return nullptr;
    if (eleDeclare == "")  // find only with name
    {
        TiXmlElement* ele = e->FirstChildElement();
        while (ele != nullptr) {
            if (ele->Attribute("name") != nullptr) {
                std::string nameValue = (string)ele->Attribute("name");
                nameValue = ReplaceVariables(nameValue);
                if (nameValue == eleName) {
                    return ele;
                }
            }
            ele = ele->NextSiblingElement();
        }
        return ele;
    } else  // find with name and declare
    {
        TiXmlElement* ele = e->FirstChildElement(eleDeclare.c_str());
        while (ele != nullptr) {
            if (ele->Attribute("name") != nullptr) {
                std::string nameValue = (string)ele->Attribute("name");
                nameValue = ReplaceVariables(nameValue);
                if (nameValue == eleName) {
                    return ele;
                }
            }
            ele = ele->NextSiblingElement(eleDeclare.c_str());
        }
        return ele;
    }
 
    return nullptr;
}
 
string TRestMetadata::GetUnits(TiXmlElement* e) {
    if (e == nullptr) {
        RESTWarning << "TRestMetadata::GetUnits(): NULL element given!" << RESTendl;
        return "";
    }
 
    string valstr = e->Attribute("value") == nullptr ? "" : e->Attribute("value");
    string unitattr = e->Attribute("units") == nullptr ? "" : e->Attribute("units");
 
    string unitembeded = REST_Units::FindRESTUnitsInString(valstr);
    if (IsUnit(unitembeded)) {
        return unitembeded;
    }
    if (IsUnit(unitattr)) {
        return unitattr;
    }
    return "";
}
 
pair<string, string> TRestMetadata::GetParameterAndUnits(string parName, TiXmlElement* e) {
    string parvalue;
    if (e == nullptr) {
        parvalue = GetParameter(parName);
        e = fElement;
    } else {
        parvalue = GetParameter(parName, e);
    }
 
    if (parvalue == PARAMETER_NOT_FOUND_STR) {
        return {parvalue, ""};
    } else {
        // first try to use unit embeded in parvalue
        string unit = REST_Units::FindRESTUnitsInString(parvalue);
        // then try to find unit in corresponding "parameter" section
        if (unit == "") {
            TiXmlElement* paraele = GetElementWithName("parameter", parName, e);
            if (paraele != nullptr) {
                unit = GetUnits(paraele);
            }
        }
        // finally try to find unit in local section attribute
        if (unit == "") {
            unit = GetUnits(e);
        }
        return {REST_Units::RemoveUnitsFromString(parvalue), unit};
    }
    return {parvalue, ""};
}
 
TiXmlElement* TRestMetadata::StringToElement(string definition) {
    TiXmlElement* ele = new TiXmlElement("temp");
    // TiXmlDocument*doc = new TiXmlDocument();
    ele->Parse(definition.c_str(), nullptr, TIXML_ENCODING_UTF8);
    return ele;
}
 
string TRestMetadata::ElementToString(TiXmlElement* ele) {
    if (ele != nullptr) {
        // remove comments
        TiXmlNode* n = ele->FirstChild();
        while (n != nullptr) {
            TiXmlComment* cmt = n->ToComment();
            if (cmt != nullptr) {
                TiXmlNode* nn = n;
                n = n->NextSibling();
                ele->RemoveChild(nn);
                continue;
            }
            n = n->NextSibling();
        }
 
        stringstream ss;
        ss << (*ele);
        string s = ss.str();
 
        // int pos = 0;
        // int pos2 = 0;
        // while ((pos = s.find("<!--", pos)) != -1 && (pos2 = s.find("-->", pos))
        // != -1)
        //{
        //  s.replace(pos, pos2 - pos + 3, "");//3 is the length of "-->"
        //  pos = pos + 1;
        //}
 
        return s;
    }
 
    return " ";
}
 
string TRestMetadata::GetKEYStructure(std::string keyName) {
    size_t Position = 0;
    string result = GetKEYStructure(keyName, Position, fElement);
    if (result == "") result = "NotFound";
    return result;
}
string TRestMetadata::GetKEYStructure(std::string keyName, size_t& Position) {
    string result = GetKEYStructure(keyName, Position, fElement);
    if (result == "") result = "NotFound";
    return result;
}
string TRestMetadata::GetKEYStructure(std::string keyName, string buffer) {
    size_t Position = 0;
    string result = GetKEYStructure(keyName, Position, buffer);
    if (result == "") result = "NotFound";
    return result;
}
string TRestMetadata::GetKEYStructure(std::string keyName, size_t& fromPosition, string buffer) {
    TiXmlElement* ele = StringToElement(buffer);
    string result = GetKEYStructure(keyName, fromPosition, ele);
    delete ele;
    return result;
}
string TRestMetadata::GetKEYStructure(std::string keyName, size_t& fromPosition, TiXmlElement* ele) {
    RESTDebug << "Finding " << fromPosition << "th appearance of KEY Structure \"" << keyName << "\"..."
              << RESTendl;
 
    TiXmlElement* childele = ele->FirstChildElement(keyName);
    for (unsigned int i = 0; childele != nullptr && i < fromPosition; i++) {
        childele = childele->NextSiblingElement(keyName);
    }
    if (childele != nullptr) {
        string result = ElementToString(childele);
        fromPosition = fromPosition + 1;
        RESTDebug << "Found Key : " << result << RESTendl;
        return result;
    }
 
    RESTDebug << "Finding hit the end, KEY Structure not found!!" << RESTendl;
    return "";
}
 
string TRestMetadata::GetKEYDefinition(string keyName) {
    string buffer = ElementToString(fElement);
    size_t Position = 0;
    return GetKEYDefinition(keyName, Position, buffer);
}
string TRestMetadata::GetKEYDefinition(string keyName, size_t& fromPosition) {
    string buffer = ElementToString(fElement);
    return GetKEYDefinition(keyName, fromPosition, buffer);
}
string TRestMetadata::GetKEYDefinition(string keyName, string buffer) {
    size_t Position = 0;
    return GetKEYDefinition(keyName, Position, buffer);
}
string TRestMetadata::GetKEYDefinition(string keyName, size_t& fromPosition, string buffer) {
    string key = "<" + keyName;
    size_t startPos = buffer.find(key, fromPosition);
    if (startPos == string::npos) return "";
    size_t endPos = buffer.find(">", startPos);
    if (endPos == string::npos) return "";
 
    fromPosition = endPos;
 
    Int_t notDefinitionEnd = 1;
 
    while (notDefinitionEnd) {
        // We might find a problem when we insert > symbol inside a field value.
        // As for example: condition=">100" This patch checks if the definition
        // finishes in "= If it is the case it searches the next > symbol ending
        // the definition.
 
        string def = RemoveWhiteSpaces(buffer.substr(startPos, endPos - startPos));
 
        if ((TString)def[def.length() - 1] == "\"" && (TString)def[def.length() - 2] == "=")
            endPos = buffer.find(">", endPos + 1);
        else
            notDefinitionEnd = 0;
    }
 
    string result = buffer.substr(startPos, endPos - startPos + 1);
    if (result[result.size() - 2] != '/') result.insert(result.size() - 1, 1, '/');
    // cout << result << endl << endl;
    // getchar();
    return result;
}
 
string TRestMetadata::FieldNamesToUpper(string definition) {
    string result = definition;
    TiXmlElement* e = StringToElement(definition);
    if (e == nullptr) return nullptr;
 
    TiXmlAttribute* attr = e->FirstAttribute();
    while (attr != nullptr) {
        string parName = std::string(attr->Name());
 
        size_t pos = 0;
        result = Replace(result, parName, ToUpper(parName), pos);
 
        attr = attr->Next();
    }
 
    return result;
}
 
std::string TRestMetadata::GetFieldValue(std::string fieldName, std::string definition, size_t fromPosition) {
    TiXmlElement* ele = StringToElement(FieldNamesToUpper(definition));
    string value = GetFieldValue(ToUpper(fieldName), ele);
    delete ele;
    return value;
}
 
string TRestMetadata::GetParameter(string parName, size_t& pos, string inputString) {
    pos = inputString.find(parName, pos);
 
    TiXmlElement* ele = StringToElement(inputString);
    string value = GetParameter(parName, ele);
 
    delete ele;
    return value;
}
 
string TRestMetadata::ReplaceVariables(const string buffer) {
    RESTDebug << "Entering ... TRestMetadata::ReplaceVariables (" << buffer << ")" << RESTendl;
    string outputBuffer = buffer;
 
    // replace variables with mark ${}
    int startPosition = 0;
    int endPosition = 0;
    while ((startPosition = outputBuffer.find("${", endPosition)) != (int)string::npos) {
        endPosition = outputBuffer.find("}", startPosition + 2);
        if (endPosition == (int)string::npos) break;
 
        string expression = outputBuffer.substr(startPosition + 2, endPosition - startPosition - 2);
 
        int replacePos = startPosition;
        int replaceLen = endPosition - startPosition + 1;
 
        string sysenv = getenv(expression.c_str()) != nullptr ? getenv(expression.c_str()) : "";
        string proenv = fVariables.count(expression) > 0 ? fVariables[expression] : "";
        string argenv = REST_ARGS.count(expression) > 0 ? REST_ARGS[expression] : "";
 
        if (sysenv != "") {
            outputBuffer.replace(replacePos, replaceLen, sysenv);
            endPosition = 0;
        } else if (argenv != "") {
            outputBuffer.replace(replacePos, replaceLen, argenv);
            endPosition = 0;
        } else if (proenv != "") {
            outputBuffer.replace(replacePos, replaceLen, proenv);
            endPosition = 0;
        } else {
            RESTError << this->ClassName() << ", replace env : cannot find \"${" << expression
                      << "}\" in either system or program env, exiting..." << RESTendl;
            exit(1);
        }
    }
 
    if (buffer != outputBuffer) RESTDebug << "Replaced by : " << outputBuffer << RESTendl;
    return outputBuffer;
}
 
string TRestMetadata::ReplaceConstants(const string buffer) {
    RESTDebug << "Entering ... TRestMetadata::ReplaceConstants (" << buffer << ")" << RESTendl;
    string outputBuffer = buffer;
 
    // replace bare constant name. ignore sub strings.
    // e.g. variable "nCh" with value "3" cannot replace the string "nChannels+1"
    for (auto iter : fConstants) {
        int pos = outputBuffer.find(iter.first, 0);
        while (pos != -1) {
            char next =
                (pos + iter.first.size()) >= outputBuffer.size() ? 0 : outputBuffer[pos + iter.first.size()];
            char prev = pos == 0 ? 0 : outputBuffer[pos - 1];
            if (!isalpha(next) && !isalpha(prev)) {
                outputBuffer.replace(pos, iter.first.size(), iter.second);
                pos = outputBuffer.find(iter.first, pos + iter.second.size());
            } else {
                pos = outputBuffer.find(iter.first, pos + iter.first.size());
            }
        }
    }
 
    if (buffer != outputBuffer) RESTDebug << "Replaced by : " << outputBuffer << RESTendl;
    return outputBuffer;
}
 
string TRestMetadata::SearchFile(string filename) {
    if (TRestTools::fileExists(filename)) {
        return filename;
    } else {
        auto pathString = GetSearchPath();
        auto paths = Split((string)pathString, ":");
        return TRestTools::SearchFileInPath(paths, filename);
    }
}
 
void TRestMetadata::PrintTimeStamp(Double_t timeStamp) {
    cout.precision(10);
 
    time_t tt = (time_t)timeStamp;
    struct tm* tm = localtime(&tt);
 
    char date[20];
    strftime(date, sizeof(date), "%Y-%m-%d", tm);
    cout << "Date : " << date << endl;
 
    char time[20];
    strftime(time, sizeof(time), "%H:%M:%S", tm);
    cout << "Time : " << time << endl;
    cout << "++++++++++++++++++++++++" << endl;
}
 
void TRestMetadata::PrintConfigBuffer() {
    if (fElement != nullptr) {
        fElement->Print(stdout, 0);
        cout << endl;
    } else {
        if (configBuffer != "") {
            auto ele = StringToElement(configBuffer);
            ele->Print(stdout, 0);
            cout << endl;
            delete ele;
        } else {
            cout << "N/A" << endl;
        }
    }
}
 
void TRestMetadata::WriteConfigBuffer(string fname) {
    if (fElement != nullptr) {
        FILE* f = fopen(fname.c_str(), "at");
        fElement->Print(f, 0);
        fclose(f);
        return;
    } else if (configBuffer != "") {
        FILE* f = fopen(fname.c_str(), "at");
        auto ele = StringToElement(configBuffer);
        ele->Print(f, 0);
        fclose(f);
        delete ele;
        return;
    }
 
    RESTError << "Something missing here. Call the police" << RESTendl;
}
 
void TRestMetadata::PrintMessageBuffer() { cout << messageBuffer << endl; }
 
void TRestMetadata::PrintMetadata() {
    RESTMetadata << "+++++++++++++++++++++++++++++++++++++++++++++" << RESTendl;
    RESTMetadata << this->ClassName() << " content" << RESTendl;
    RESTMetadata << "Config file : " << fConfigFileName << RESTendl;
    RESTMetadata << "+++++++++++++++++++++++++++++++++++++++++++++" << RESTendl;
    RESTMetadata << "Name : " << GetName() << RESTendl;
    RESTMetadata << "Title : " << GetTitle() << RESTendl;
    RESTMetadata << "REST Version : " << GetVersion() << RESTendl;
    if (fOfficialRelease)
        RESTMetadata << "REST Official release: Yes" << RESTendl;
    else
        RESTMetadata << "REST Official release: No" << RESTendl;
    if (fCleanState)
        RESTMetadata << "Clean state: Yes" << RESTendl;
    else
        RESTMetadata << "Clean state: No" << RESTendl;
    RESTMetadata << "REST Commit : " << GetCommit() << RESTendl;
    if (GetLibraryVersion() != "0.0")
        RESTMetadata << "REST Library version : " << GetLibraryVersion() << RESTendl;
    RESTMetadata << "---------------------------------------" << RESTendl;
}
 
TString TRestMetadata::GetVersion() { return fVersion; }
 
TString TRestMetadata::GetCommit() { return fCommit; }
 
TString TRestMetadata::GetLibraryVersion() { return fLibraryVersion; }
 
void TRestMetadata::ReSetVersion() {
    if (!this->InheritsFrom("TRestRun"))
        RESTError << "version is a static value, you cannot set version "
                     "for a class!"
                  << RESTendl;
    else {
        fVersion = REST_RELEASE;
    }
}
 
void TRestMetadata::UnSetVersion() {
    if (!this->InheritsFrom("TRestRun"))
        RESTError << "version is a static value, you cannot set version "
                     "for a class!"
                  << RESTendl;
    else {
        fVersion = -1;
        fCommit = -1;
    }
}
 
void TRestMetadata::SetLibraryVersion(TString version) { fLibraryVersion = version; }
 
Int_t TRestMetadata::GetVersionCode() { return TRestTools::ConvertVersionCode((string)GetVersion()); }
 
std::string TRestMetadata::GetSectionName() {
    auto a = fSectionName.find('\n', 0);
    if (a != string::npos) return fSectionName.substr(0, a);
    return fSectionName;
}
 
std::string TRestMetadata::GetConfigBuffer() { return configBuffer; }
 
string TRestMetadata::GetDataMemberValue(string memberName) {
    return RESTValue(this, this->ClassName()).GetDataMemberValueString(memberName);
}
 
std::vector<string> TRestMetadata::GetDataMemberValues(string memberName, Int_t precision) {
    string result = GetDataMemberValue(memberName);
 
    result = Replace(result, "{", "");
    result = Replace(result, "}", "");
    result = Replace(result, "(", "");
    result = Replace(result, ")", "");
 
    std::vector<std::string> results = REST_StringHelper::Split(result, ",");
 
    for (auto& x : results) x = REST_StringHelper::CropWithPrecision(x, precision);
 
    return results;
}
 
TString TRestMetadata::GetVerboseLevelString() {
    TString level = "unknown";
    if (this->GetVerboseLevel() == TRestStringOutput::REST_Verbose_Level::REST_Debug) level = "debug";
    if (this->GetVerboseLevel() == TRestStringOutput::REST_Verbose_Level::REST_Info) level = "info";
    if (this->GetVerboseLevel() == TRestStringOutput::REST_Verbose_Level::REST_Essential) level = "warning";
    if (this->GetVerboseLevel() == TRestStringOutput::REST_Verbose_Level::REST_Silent) level = "silent";
 
    return level;
}
 
TString TRestMetadata::GetSearchPath() {
    string result = "";
 
    // If fElement=0 we haven't initialized the class from RML.
    // Then we skip adding user paths
    if (fElement) {
        TiXmlElement* ele = fElement->FirstChildElement("searchPath");
        while (ele != nullptr) {
            if (ele->Attribute("value") != nullptr) {
                result += (string)ele->Attribute("value") + ":";
            }
            ele = ele->NextSiblingElement("searchPath");
        }
    }
 
    if (getenv("configPath")) result += getenv("configPath") + (string) ":";
    result += REST_PATH + "/data/:";
    result += REST_PATH + "/examples/:";
    // We give priority to the official /data/ and /examples/ path.
    result += REST_USER_PATH + ":";
    if (result.back() == ':') result.erase(result.size() - 1);
 
    return ReplaceConstants(ReplaceVariables(result));
}
 
Int_t TRestMetadata::Write(const char* name, Int_t option, Int_t bufsize) {
    if (fStore) {
        configBuffer = ElementToString(fElement);
        return TNamed::Write(name, option, bufsize);
    }
    return -1;
}
 
void TRestMetadata::ReadAllParameters() {
    // we shall first add all the parameters to a temporary map to avoid
    // first parameter being overriden by the repeated parameter section
    map<string, string> parameters = GetParametersList();
 
    ReadParametersList(parameters);
}
 
void TRestMetadata::ReadParametersList(std::map<string, string>& list) {
    for (auto i : list) {
        ReadOneParameter(i.first, i.second);
    }
}
 
std::map<string, string> TRestMetadata::GetParametersList() {
    // we shall first add all the parameters to a temporary map to avoid
    // first parameter being overriden by the repeated parameter section
    map<string, string> parameters;
 
    // Loop over REST_ARGS
    auto iter = REST_ARGS.begin();
    while (iter != REST_ARGS.end()) {
        // if (parameters.count(iter->first) == 0) {
        parameters[iter->first] = iter->second;
        //}
        iter++;
    }
 
    // Loop over attribute set
    auto paraattr = fElement->FirstAttribute();
    while (paraattr != nullptr) {
        string name = paraattr->Name();
        string value = paraattr->Value();
 
        if (parameters.count(name) == 0) {
            parameters[name] = value;
        }
        // ReadOneParameter((string)name, (string)value);
        paraattr = paraattr->Next();
    }
 
    // Loop over <parameter section
    auto paraele = fElement->FirstChildElement("parameter");
    while (paraele != nullptr) {
        string name = paraele->Attribute("name");
        string value = paraele->Attribute("value");
        // In case <parameter section contains units definitions in extra attribute field,
        // not together with "value" attribute field
        // We should concat the value and units together.
        TString units = paraele->Attribute("units");
 
        if (name == "") {
            RESTWarning << "bad <parameter section: " << *paraele << RESTendl;
        } else {
            if (parameters.count(name) == 0) {
                parameters[name] = value + units;
            }
            // ReadOneParameter((string)name, (string)value);
        }
        paraele = paraele->NextSiblingElement("parameter");
    }
 
    return parameters;
}
 
void TRestMetadata::ReadOneParameter(string name, string value) {
    if (name == "name" || name == "title" || name == "verboseLevel" || name == "type" || name == "value" ||
        name == "store") {
        // we omit these parameters since they are already loaded in LoadSectionMetadata()
    } else {
        RESTValue thisactual(this, this->ClassName());
        string datamembername = ParameterNameToDataMemberName(name);
        if (datamembername != "") {
            RESTValue datamember = thisactual.GetDataMember(datamembername);
            if (!datamember.IsZombie()) {
                RESTDebug << this->ClassName() << "::ReadAllParameters(): parsing value \"" << value
                          << "\" to data member \"" << datamembername << "\"" << RESTendl;
 
                if (REST_Units::FindRESTUnitsInString(value) != "") {
                    // there is units contained in this parameter.
                    string val = REST_Units::RemoveUnitsFromString(value);
                    string unit = REST_Units::FindRESTUnitsInString(value);
 
                    if (datamember.type == "double") {
                        Double_t value = StringToDouble(val);
                        *(double*)datamember = REST_Units::ConvertValueToRESTUnits(value, unit);
                    } else if (datamember.type == "TVector2") {
                        TVector2 value = StringTo2DVector(val);
                        Double_t valueX = REST_Units::ConvertValueToRESTUnits(value.X(), unit);
                        Double_t valueY = REST_Units::ConvertValueToRESTUnits(value.Y(), unit);
                        *(TVector2*)datamember = TVector2(valueX, valueY);
                    } else if (datamember.type == "TVector3") {
                        TVector3 value = StringTo3DVector(val);
                        Double_t valueX = REST_Units::ConvertValueToRESTUnits(value.X(), unit);
                        Double_t valueY = REST_Units::ConvertValueToRESTUnits(value.Y(), unit);
                        Double_t valueZ = REST_Units::ConvertValueToRESTUnits(value.Z(), unit);
                        *(TVector3*)datamember = TVector3(valueX, valueY, valueZ);
                    } else if (datamember.type == "string") {
                        // We just ignore this case
                    } else {
                        RESTWarning << this->ClassName() << " find unit definition in parameter: " << name
                                    << ", but the corresponding data member doesn't support it. Data "
                                       "member type: "
                                    << datamember.type << RESTendl;
                        datamember.ParseString(value);
                    }
                } else {
                    datamember.ParseString(value);
                }
            } else if (datamember.name != "") {
                // this mean the datamember is found with type not recognized.
                // We won't try to find the misspelling
            } else {
                RESTDebug << this->ClassName() << "::ReadAllParameters(): parameter \"" << name
                          << "\" not recognized for automatic load" << RESTendl;
                vector<string> availableparameters;
 
                vector<string> datamembers = thisactual.GetListOfDataMembers();
                for (unsigned int i = 0; i < datamembers.size(); i++) {
                    string parameter = DataMemberNameToParameterName(datamembers[i]);
                    if (parameter != "") {
                        if (parameter == "name" || parameter == "title" || parameter == "verboseLevel" ||
                            parameter == "type" || parameter == "value" || parameter == "store") {
                        } else {
                            availableparameters.push_back(parameter);
                        }
                    }
                }
 
                int mindiff = 100;
                string hintParameter = "";
                for (auto parameter : availableparameters) {
                    int diff = DiffString(name, parameter);
                    if (diff < mindiff) {
                        mindiff = diff;
                        hintParameter = parameter;
                    }
                }
 
                // we regard the unset parameter with less than 2 characters different from
                // the data member as "misspelling" parameter. We prompt a warning for it.
                if (hintParameter != "" && mindiff <= 2) {
                    RESTWarning << this->ClassName() << "::ReadAllParameters(): parameter \"" << name
                                << "\" not recognized for automatic load, did you mean \"" << hintParameter
                                << "\" ?" << RESTendl;
                    GetChar();
                }
            }
        }
    }
}
 
TRestStringOutput& TRestStringOutput::operator<<(endl_t et) {
    if (et.TRestMetadataPtr->GetVerboseLevel() <= TRestStringOutput::REST_Verbose_Level::REST_Info) {
        et.TRestMetadataPtr->AddLog(this->buf.str());
    }
 
    if (this->iserror) {
        if (this->verbose == TRestStringOutput::REST_Verbose_Level::REST_Warning) {
            et.TRestMetadataPtr->SetWarning(this->buf.str(), false);
        }
        if (this->verbose == TRestStringOutput::REST_Verbose_Level::REST_Silent) {
            et.TRestMetadataPtr->SetError(this->buf.str(), false);
        }
    }
 
    if (et.TRestMetadataPtr->GetVerboseLevel() >= this->verbose) {
        this->flushstring();
    } else {
        this->resetstring();
    }
 
    return *this;
}
 
void TRestMetadata::AddLog(string log, bool print) {
    messageBuffer += log + "\n";
    if (messageBuffer.size() > 1000) {
        messageBuffer.erase(0, messageBuffer.size() - 1000);
    }
}
 
void TRestMetadata::SetError(string message, bool print, int maxPrint) {
    fError = true;
    fNErrors++;
    if (message != "") {
        fErrorMessage += message + "\n";
        if (print && fNErrors < maxPrint) {
            cout << message << endl;
        }
    }
}
 
void TRestMetadata::SetWarning(string message, bool print, int maxPrint) {
    fWarning = true;
    fNWarnings++;
    if (message != "") {
        fWarningMessage += message + "\n";
        if (print && fNWarnings < maxPrint) {
            RESTWarning << message << RESTendl;
        }
    }
}
 
TString TRestMetadata::GetErrorMessage() {
    if (GetError())
        return fErrorMessage;
    else
        return "No error!";
}
 
TString TRestMetadata::GetWarningMessage() {
    if (GetWarning())
        return fWarningMessage;
    else
        return "No warning!";
}
 
void TRestMetadata::Merge(const TRestMetadata& metadata) {
    if (!metadata.InheritsFrom(ClassName())) {
        RESTError << "TRestMetadata::Merge. Metadata is not of type " << ClassName() << RESTendl;
        exit(1);
    }
 
    if (fName.IsNull()) {
        fName = metadata.GetName();
    }
}
 
UInt_t TRestMetadata::GetVersionMajor() const {
    TString major = fVersion(0, fVersion.First('.'));
    return major.Atoi();
}
 
UInt_t TRestMetadata::GetVersionMinor() const {
    TString minor = fVersion(fVersion.First('.') + 1, fVersion.Last('.'));
    return minor.Atoi();
}
 
UInt_t TRestMetadata::GetVersionPatch() const {
    TString patch = fVersion(fVersion.Last('.') + 1, fVersion.Length());
    return patch.Atoi();
}