CORE_OptionsReader.h

Go to the documentation of this file.

#ifndef CORE_OptionsReader_H
#define CORE_OptionsReader_H
 
//base class header
#include "CORE_Object.h"
 
//file system  header
#include "CORE_IO.h"
//output stream
#include "CORE_Out.h"
//map header
#include <map>
 
//string conversion header
#include<charconv>
#include <string>
 
//file header
#include <fstream>
 
//data header
#include "CORE_Chrono.h"
 
class CORE_OptionsReader : public virtual CORE_Object {
   
    //attributes
private :
 
  
    
public:
    // CONSTRUCTORS 
    CORE_OptionsReader(void) {
    }
  
    // DESTRUCTORS 
    virtual ~CORE_OptionsReader(void) {
    }
    
 
 
public : 
    // CREATE class
   
 
    //options reader
    //==============
    virtual  tMemSize getMemorySize() const override {
        return sizeof(*this)+getContentsMemorySize();
    }
    
 
    static tBoolean ReadOptions(const tString& fileName, std::map<tString,tString>& options);
    
    static void ReadOptions(int argc,char *argv[],std::map<tString,tString>& options);
    
    static tBoolean ReadOption(int nArgs,char *argv[],const tString& optionName,tString& optionValue);
    
    template<typename T,std::enable_if_t<std::is_floating_point_v<T>> * = nullptr>
    inline static T ReadNumericValue(const tString& strValue) {
        T var;
        std::istringstream iss;
        iss.str(strValue);
        iss >> var;
        // deal with any error bits that may have been set on the stream
        return var;
        
    }
     
    template<typename T,std::enable_if_t<std::is_integral_v<T>> * = nullptr>
    inline static T ReadNumericValue(const tString& strValue) {
        T var=0;
        std::from_chars(strValue.data(), strValue.data() + strValue.size(), var);
        return var;
        
    }
 
    inline static tReal ReadReal(const tString& strValue) {
        return ReadNumericValue<tReal>(strValue);
        
    }
    inline static tInteger ReadInteger(const tString& strValue) {
        return ReadNumericValue<tInteger>(strValue);
        
    }
    inline static tInteger ReadRelativeInteger(const tString& strValue) {
        return ReadNumericValue<tRelativeInteger>(strValue);
        
    }
    inline static tInt ReadInt(const tString& strValue) {
        return ReadNumericValue<tInt>(strValue);
        
    }
 
    
    inline static tBoolean ReadBoolean(const tString& strValue) {
        if (strValue.length()==0) return true;
        tString boolValue=strValue;
        core_functions::trim(boolValue);
        core_functions::toLower(boolValue);
        if (strValue.compare("")==0) return true;
        if (strValue.compare("true")==0) return true;
        if (strValue.compare("1")==0) return true;
        return false;
    }
 
    
    template<class T>
    inline static tBoolean ReadVector(tString& current,std::vector<T>& values) {
        // length of the string
        tIndex lmax=current.length();
    
        
        // find a [, current is set to the chars after [
        tIndex indexOB=current.find("[");
        if (indexOB!=tString::npos) {
            current=current.substr(indexOB+1);
            lmax=current.length();
            values.clear();
        }
        
        
      
        //max index to read
        tIndex indexMax=current.find("]");
        if (indexMax==tString::npos) indexMax=lmax;
        // find a coma
        tIndex indexC=current.find(",");
        tIndex i=0;
        T value;
        while (indexC<indexMax) {//the first exists
            // read the value at index i
            core_functions::parse<T>(current.substr(0,indexC),value);
            // add it
            values.push_back(value);
            // get the next value
            current=current.substr(indexC+1,lmax-indexC-1);
            lmax=current.length();
            indexC=current.find(",");
            indexMax=current.find("]");
            if (indexMax==tString::npos) {
                indexMax=lmax;
            }
            
            i++;
        }
        
        
        //set the current to chars after ] it it exists 
        
        tString v=current;
        if (indexMax<lmax) {
            // take the string v before ]
            v=current.substr(0,indexMax);
            // erase from current all the string before ]
            current=current.substr(indexMax+1,lmax-indexMax-1);
            // erase the ,
            if (current[0]==',') current=current.substr(1);
        }
        
        
        
        // parse the last value
        core_functions::parse(v,value);
        values.push_back(value);
        
        
        return true;
    }
     
    template<class T,tIndex N>
    inline static tBoolean ReadArray(tString& current,std::array<T,N>& values) {
 
 
        //initialize
       
        for(auto& v:values) v=0;
        T* iValue=values.data();
        const T* eValue=values.data()+N;
        
        // length of the string
        tIndex lmax=current.length();
    
        
        // find a [, current is set to the chars after [
        tIndex indexOB=current.find("[");
        if (indexOB!=tString::npos) {
            current=current.substr(indexOB+1);
            lmax=current.length();
        }
        
        
      
        //max index to read
        tIndex indexMax=current.find("]");
        if (indexMax==tString::npos) indexMax=lmax;
        // find a coma
        tIndex indexC=current.find(",");
        while ((indexC<indexMax)&&(iValue!=eValue)) {//the first exists
 
            // read the value at index i
            core_functions::parse<T>(current.substr(0,indexC),(*iValue));
            iValue++;
            
            // get the next value
            current=current.substr(indexC+1,lmax-indexC-1);
            lmax=current.length();
            indexC=current.find(",");
            indexMax=current.find("]");
            if (indexMax==tString::npos) {
                indexMax=lmax;
            }
          
        }
        
        
        //set the current to chars after ] it it exists
        tString v=current;
        if (indexMax<lmax) {
            // take the string v before ]
            v=current.substr(0,indexMax);
            // erase from current all the string before ]
            current=current.substr(indexMax+1,lmax-indexMax-1);
            // erase the ,
            if (current[0]==',') current=current.substr(1);
        }
        
        
        
        // parse the last value
        if (iValue!=eValue) core_functions::parse(v,(*iValue));
        
        
        return true;
    }
    
    inline static tString  ReadPath(const tString& value) {
        return CORE_IO::GetAbsolutePath(value);
    }
 
    
    //options saver
    //=============
    inline static tBoolean SaveOptionsToFile(const std::map<tString,std::map<tString,tString> >& manOptions,
                                             const std::map<tString,tString>& options) {
        
        //get the output path
        std::stringstream fileName;
        std::map<tString,tString>::const_iterator iOptions=options.find("output-path");
        if (iOptions!=options.end()) fileName<<ReadPath(iOptions->second);
        else fileName<<".";
        fileName<<"/options.txt";
        return SaveOptionsToFile(fileName.str(),manOptions,options);
    }
  
    static tBoolean SaveOptionsToFile(const tString& fileName,
                                      const std::map<tString,std::map<tString,tString> >& manOptions,
                                      const std::map<tString,tString>& options);
    
    static inline CORE_Out& PrintOptions(CORE_Out& out,
                                         const std::map<tString,tString>& options)  {
 
        for_each(options.begin(),options.end(),
                 [&](auto& opt) {
                     out.println(opt.first+"="+opt.second);
                 });
        return out;
    }
 
 
private:
    static void RegisterOption(tString& arg,std::map<tString,tString>& options);
    
    static void ReadOptionValue(tString& optionValue);
 
    
};
 
 
#endif