CORE_OptionsList.h

#ifndef CORE_OptionsList_H
#define CORE_OptionsList_H
 
//base class header
#include "CORE_Object.h"
 
 
//map header
#include <map>
#include <vector>
#include <valarray>
#include <array>
 
 
//shared pointer header
#include "shared_pointer.h"
 
//string conversion header
#include<charconv>
#include <string>
 
 
//utility headers
#include "functions_string.h"
#include "functions_numeric.h"
 
class CORE_Out;
 
class CORE_OptionsList : public virtual CORE_Object {
    
    //attributes
private :
 
    //class type
    typedef CORE_OptionsList SelfClass;
    typedef CORE_Object SuperClass;
    
    std::map<tString,tString> mOptions;
    std::map<tString,std::map<tString,tString> >mManOptions;
    tBoolean mIsOptionsNameCaseSensitive;
    
public:
    // CONSTRUCTORS 
    CORE_OptionsList(void);
  
    // DESTRUCTORS 
    virtual ~CORE_OptionsList(void);
 
 
public : 
    // CREATE class
 
    static inline CORE_UniquePointer<SelfClass> New() {
        CORE_UniquePointer<SelfClass> p(new SelfClass(),SelfClass::Delete());
        return p;
    }
 
    //options reader
    //==============
    virtual  tMemSize getMemorySize() const override {
        return sizeof(*this)+getContentsMemorySize();
    }
    virtual tMemSize getContentsMemorySize() const override {
        tMemSize mem=SuperClass::getContentsMemorySize();
        for(const auto& opt:mOptions) mem+=(opt.first.length()+opt.second.length())*sizeof(tChar);
        
        for(const auto& manOpt:mManOptions) {
            for(const auto& opt:manOpt.second) {
                mem+=(opt.first.length()+opt.second.length())*sizeof(tChar);
            }
            mem+=manOpt.first.length()*sizeof(tChar);
        }
            
        return mem;
    }
 
    //iterator manager on options
 
    std::map<tString,tString>::iterator begin() {
        return mOptions.begin();
    }
 
    std::map<tString,tString>::iterator end() {
        return mOptions.end();
    }
    std::map<tString,tString>::const_iterator cbegin() const {
        return mOptions.cbegin();
    }
 
    std::map<tString,tString>::const_iterator cend() const {
        return mOptions.cend();
    }
 
 
    //type of options
    //===============
 
    inline void setIsOptionsNameCaseSensitive(const tBoolean& isOptNameCS) {
        mIsOptionsNameCaseSensitive=isOptNameCS;
        
    }
    inline const tBoolean& isOptionsNameCaseSensitive() const {
        return mIsOptionsNameCaseSensitive;
        
    }
 
 
    //clear the options
    //=================
    inline void clear() {
        mOptions.clear();
        mManOptions.clear();
        
    }
 
 
    //option setting
    //==============
 
 
    inline CORE_OptionsList& operator=(const CORE_OptionsList& options)  {
 
        auto iter=options.cbegin();
        auto endIter=options.cend();
        while (iter!=endIter) {
            mOptions[iter->first]=iter->second;
            iter++;
        }
        
        mIsOptionsNameCaseSensitive=options.isOptionsNameCaseSensitive();
        return *this;
    }
  
    inline void setManOption(const tString& category,const tString& optName,const tString& man) {
        mManOptions[category][optName]=man;
    }
    inline void setOptionValue(const tString& optName,const tBoolean& value) {
        tString key=optName;
        if (!mIsOptionsNameCaseSensitive) functions_string::toLower(key);
        
        if (value) mOptions[key]="true";
        else mOptions[key]="false";
    }
    
    //accessor operator
    //==================
 
    inline tString& operator[](const tString& optName)  {
        //register the default value
        auto iOption=mOptions.find(optName);
        if (iOption==mOptions.end()) {
            mOptions[optName]="";
            iOption=mOptions.find(optName);
        }
        //return the value
        return iOption->second;
    }
     
    
  
    template<typename T>
    inline void setOptionValue(const tString& optName,const T& value) {
        tString key=optName;
        if (!mIsOptionsNameCaseSensitive) functions_string::toLower(key);
        
        std::stringstream sstr;
        sstr<<value;
 
        mOptions[key]=sstr.str();
    }
    template<typename T>
    inline void setOptionValue(const tString& optName,const std::initializer_list<T>& values) {
        tString key=optName;
        if (!mIsOptionsNameCaseSensitive) functions_string::toLower(key);
 
        std::stringstream sstr;
        sstr<<"[";
        for(const auto& v:values) sstr<<v<<",";
        if (values.size()>0) sstr.seekp(-1,sstr.cur); 
        sstr<<"]";
        mOptions[key]=sstr.str();
    }
    template<typename T>
    inline void setOptionValue(const tString& optName,const std::valarray<T>& values) {
        tString key=optName;
        if (!mIsOptionsNameCaseSensitive) functions_string::toLower(key);
 
        std::stringstream sstr;
        sstr<<"[";
        for(const auto& v:values) sstr<<v<<",";
        if (values.size()>0) sstr.seekp(-1,sstr.cur); 
        sstr<<"]";
        mOptions[key]=sstr.str();
    }
    template<typename T>
    inline void setOptionValue(const tString& optName,const std::vector<T>& values) {
        tString key=optName;
        if (!mIsOptionsNameCaseSensitive) functions_string::toLower(key);
        
        std::stringstream sstr;
        sstr<<"[";
        for(const auto& v:values) sstr<<v<<",";
        if (values.size()>0) sstr.seekp(-1,sstr.cur); 
        sstr<<"]";
        mOptions[key]=sstr.str();
    }
    template<typename T,tIndex N>
    inline void setOptionValue(const tString& optName,const std::array<T,N>& values) {
        tString key=optName;
        if (!mIsOptionsNameCaseSensitive) functions_string::toLower(key);
        
        std::stringstream sstr;
        sstr<<"[";
        for(const auto& v:values) sstr<<v<<",";
        if (values.size()>0) sstr.seekp(-1,sstr.cur); 
        sstr<<"]";
        mOptions[key]=sstr.str();
    }
    
 
 
    //option getting
    //===============
 
    //accessor operator
    //==================
 
    inline tString  operator[](const tString& optName) const {
        tString optValue="";
        getOptionValue(optName,optValue);
        return optValue;
    }
 
    inline tBoolean removeOption(const tString& optName) {
        std::map<tString,tString>::const_iterator  iOptions=mOptions.find(optName);
        if (iOptions!=mOptions.end()) {
            mOptions.erase(iOptions);
            return true;
        }
        return false;
    }
    inline  tBoolean  getOptionValue(const tString& optName,tString& optValue) const {
        
        tString key=optName;
        if (!mIsOptionsNameCaseSensitive) functions_string::toLower(key);
        
        std::map<tString,tString>::const_iterator  iOptions=mOptions.find(key);
        if (iOptions==mOptions.end()) return false;
 
        optValue=iOptions->second;
        
        // deal with any error bits that may have been set on the stream
        return true;
    }
    
    template<typename T> requires (functions_type::isRealType<T>)
    inline  tBoolean  getOptionValue(const tString& optName,T& optValue) const {
 
        tString strValue;
        tBoolean ok=getOptionValue(optName,strValue);
        if (ok) {
            std::istringstream iss;
            iss.str(strValue);
            iss >> optValue;
        }
        return ok;
    }
    
 
    template<typename T> requires (functions_type::isIntegerType<T>)
    inline  tBoolean  getOptionValue(const tString& optName,T& optValue) const {
        tString strValue;
        tBoolean ok=getOptionValue(optName,strValue);
        if (ok) {
            std::from_chars(strValue.data(), strValue.data() + strValue.size(), optValue);
        }
        return ok;
        
    }
 
    
    inline  tBoolean  getOptionValue(const tString& optName,tBoolean& optValue) const {
        tString strValue;
        tBoolean ok=getOptionValue(optName,strValue);
        if (ok) {
            functions_string::trim(strValue);
            if (strValue.length()==0)  {
                optValue=true;
            } else {
                
                switch(strValue[0]) {
                case 't':
                case 'T':
                case '1':
                    optValue=true;
                    break;
                default:
                    optValue=false;
                    break;
                }
            }
        }
        return ok;
    }
    
      
    template<class T> 
    inline tBoolean getOptionValue(const tString& optName,std::vector<T>& optValues) const {
        
        tString strValue;
        tBoolean ok=getOptionValue(optName,strValue);
        
        if (!ok) return false;
        
        // length of the string
        tIndex lmax=strValue.length();
        
        
        //clear optValues
        optValues.clear();
        
        // find first open brace ('[' or '(') , strValue is set to the chars after open brace
        tIndex indexOB=strValue.find("[");
        if (indexOB!=tString::npos) {
            strValue=strValue.substr(indexOB+1);
        } else {
            indexOB=strValue.find("(");
            if (indexOB!=tString::npos) {
                strValue=strValue.substr(indexOB+1);
            }
        }
        
        
      
        //find first close brace (']' or ')') max string to analyse is inside [0,indexMax] 
        tIndex indexMax=strValue.find("]");
        if (indexMax==tString::npos) {
            indexMax=strValue.find(")");
            if (indexMax==tString::npos) {
                indexMax=lmax;
            }
        }
        
        // find a coma
        tIndex indexC=strValue.find(",");
        tIndex i=0;
        T value;
        while (indexC<indexMax) {//the first exists
            // read the value at index i
            functions_numeric::parse<T>(strValue.substr(0,indexC),value);
            // add it
            optValues.push_back(value);
            
            // get the next value
            strValue=strValue.substr(indexC+1,lmax-indexC-1);
 
            //max leng to analyse
            lmax=strValue.length();
 
            //get the next value
            indexC=strValue.find(",");
            
            //get the close brace index 
            indexMax=strValue.find("]");
            if (indexMax==tString::npos) {
                indexMax=strValue.find(")");
                if (indexMax==tString::npos) {
                    indexMax=lmax;
                }
            }
            //next value
            i++;
        }
        
        
        //set the strValue to chars after ] it it exists 
        
        tString v=strValue;
        if (indexMax<lmax) {
            // take the string v before ]
            v=strValue.substr(0,indexMax);
            // erase from strValue all the string before ]
            strValue=strValue.substr(indexMax+1,lmax-indexMax-1);
            // erase the ,
            if (strValue[0]==',') strValue=strValue.substr(1);
        }
        
        
        
        // parse the last value
        functions_numeric::parse(v,value);
        optValues.push_back(value);
        
        
        return true;
    }
         
    template<class T,tIndex N>
    inline  tBoolean getOptionValue(const tString& optName,std::array<T,N>& optValues) const {
        
        tString strValue;
        tBoolean ok=getOptionValue(optName,strValue);
        if (!ok) return false;
          //initialize
       
        for(auto& v:optValues) v=0;
        T* iValue=optValues.data();
        const T* eValue=optValues.data()+N;
        
        // length of the string
        tIndex lmax=strValue.length();
    
 
         // find first open brace ('[' or '(') , strValue is set to the chars after open brace
        tIndex indexOB=strValue.find("[");
        if (indexOB!=tString::npos) {
            strValue=strValue.substr(indexOB+1);
        } else {
            indexOB=strValue.find("(");
            if (indexOB!=tString::npos) {
                strValue=strValue.substr(indexOB+1);
            }
        }
        
      
        //find first close brace (']' or ')') max string to analyse is inside [0,indexMax] 
        tIndex indexMax=strValue.find("]");
        if (indexMax==tString::npos) {
            indexMax=strValue.find(")");
            if (indexMax==tString::npos) {
                indexMax=lmax;
            }
        }
      
        
        // find a coma
        tIndex indexC=strValue.find(",");
        while ((indexC<indexMax)&&(iValue!=eValue)) {//the first exists
 
            // read the value at index i
            functions_numeric::parse<T>(strValue.substr(0,indexC),(*iValue));
            iValue++;
            
            // get the next value
            strValue=strValue.substr(indexC+1,lmax-indexC-1);
            lmax=strValue.length();
            indexC=strValue.find(",");
            
            //find first close brace (']' or ')') max string to analyse is inside [0,indexMax] 
            indexMax=strValue.find("]");
            if (indexMax==tString::npos) {
                indexMax=strValue.find(")");
                if (indexMax==tString::npos) {
                    indexMax=lmax;
                }
            }
            
        }
        
        
        //set the strValue to chars after ] it it exists
        tString v=strValue;
        if (indexMax<lmax) {
            // take the string v before ]
            v=strValue.substr(0,indexMax);
            // erase from strValue all the string before ]
            strValue=strValue.substr(indexMax+1,lmax-indexMax-1);
            // erase the ,
            if (strValue[0]==',') strValue=strValue.substr(1);
        }
        
        
        
        // parse the last values
        while (iValue!=eValue) {
            functions_numeric::parse(v,(*iValue));
            iValue++;
        }
        
        
        
        return true;
    }
 
    static tBoolean ReadOption(int nArgs,char *argv[],
                               const tBoolean& isCaseSensitive,const tString& optionName,
                               tString& optionValue);
    template<typename T> requires ( (functions_type::isIntegerType<T>) && !(functions_type::isBooleanType<T>) )
    inline static tBoolean ReadOption(int nArgs,char *argv[],
                                      const tBoolean& isCaseSensitive,const tString& optionName,
                                      T& optionValue) {
        tString strValue="";
        if (ReadOption(nArgs,argv,isCaseSensitive,optionName,strValue)) {
            std::from_chars(strValue.data(), strValue.data() + strValue.size(), optionValue);
            return true;
        }
        return false;
    }
    template<typename T> requires (functions_type::isRealType<T>)
    inline static tBoolean ReadOption(int nArgs,char *argv[],
                                      const tBoolean& isCaseSensitive,const tString& optionName,
                                      T& optionValue) {
        tString strValue="";
        if (ReadOption(nArgs,argv,isCaseSensitive,optionName,strValue)) {
            std::istringstream iss;
            iss.str(strValue);
            iss >> optionValue;
            return true;
        }
        return false;
    }
    template<typename T> requires (functions_type::isBooleanType<T>)
    inline static tBoolean ReadOption(int nArgs,char *argv[],
                                      const tBoolean& isCaseSensitive,const tString& optionName,
                                      T& optionValue) {
        tString strValue="";
        if (ReadOption(nArgs,argv,isCaseSensitive,optionName,strValue)) {
            functions_string::trim(strValue);
            if (strValue.length()==0)  {
                optionValue=true;
            } else {
                switch(strValue[0]) {
                case 't':
                case 'T':
                case '1':
                    optionValue=true;
                    break;
                default:
                    optionValue=false;
                    break;
                }
            }
            return true;
        }
        return false;
    }
 
 
    //options loader && saver
    //=======================
    
    tBoolean loadFromFile(const tString& fileName);
    
    void loadFromCommandLine(int argc,char *argv[]);
    
   
  
    tBoolean saveToFile(const tString& fileName) const;
    
    tBoolean saveToFile() const;
 
 
   
    // string representation
    //======================
    
    virtual tString toString() const override;
    
    
private:
    void setOption(tString& arg);
 
    
    static void ReadOptionValue(tString& optionValue);
    
   
   
    
};
 
 
#endif