NamelistReader.hpp

Go to the documentation of this file.

#ifndef NAMELISTREADER_HPP
#define NAMELISTREADER_HPP
 
#include <iostream>
#include <sstream>
#include <fstream>
#include <string>
#include <vector>
#include <algorithm>
#include <cctype>
 
namespace NLReader{
 
using namespace std;
 
enum Expect {
    Ampersand=0,
    NLName,
    ParaNameOrEnd,
    Equals,
    Value,
    ValueOrEOL
};
 
enum ReadFrom {
    ReadFromFile=0,
    ReadFromString
};
 
enum Create {
    CreateManually=0
};
 
// trim from left
inline string& ltrim(string& s, const char* t = " \t\n\r\f\v")
{
    s.erase(0, s.find_first_not_of(t));
    return s;
}
 
// trim from right
inline string& rtrim(string& s, const char* t = " \t\n\r\f\v")
{
    s.erase(s.find_last_not_of(t) + 1);
    return s;
}
 
// trim from left & right
inline string& trim(string& s, const char* t = " \t\n\r\f\v")
{
    return ltrim(rtrim(s, t), t);
}
 
struct Param{
    string name;
    bool used;
    vector<string> values;
 
    Param(string name)
        : name(name), used(false)
    {}
};
 
struct NameList{
    string name;
    vector<Param> params;
 
    NameList(string name)
        : name(name)
    {}
 
    void add_param(string word)
    {
        params.push_back(Param(word));
    }
 
    void add_value(string word)
    {
        params[params.size()-1].values.push_back(word);
    }
};
 
static inline string get_first_word(string& str, int start){
    for (string::size_type i = start; i < str.size(); i++){
        if ((str[i]>=48 && str[i]<=57) || (str[i]>=65 && str[i]<=90) ||
            (str[i]>=97 && str[i]<=122) || str[i]==95){
            // still in word (0-9, A-Z, a-z, _)
        } else {
            // Not in word
            return str.substr(start, i-start);
        }
    }
    return str.substr(start,str.size()-start);
}
 
static inline string get_first_value(string& str, int start){
    bool in_squote=false;
    bool in_dquote=false;
    for (string::size_type i = start; i < str.size(); i++){
        if (in_dquote==true || in_squote==true){
            if (str[i]==34) in_dquote=false;
            if (str[i]==39) in_squote=false;
        } else {
            if (str[i]==34) in_dquote=true;
            if (str[i]==39) in_squote=true;
            if (str[i]=='!' || str[i]==' ' || str[i]=='\t'|| str[i]=='\r'|| str[i]=='\f'|| str[i]=='\v'){
                // Not in word
                return str.substr(start, i-start);
            }
        }
    }
    return str.substr(start,str.size()-start);
}
 
static inline string lower_case_copy(const string& str){
    // Make copy
    string lc_str = str;
 
    // Make lower case
    for (int i = 0; i<lc_str.size(); i++)
        lc_str[i]=tolower(lc_str[i]);
 
    return lc_str;
}
 
template<typename T>
static inline T string_to_param(string& param);
 
template<>
bool string_to_param<bool>(string& param){
    // Make lower case copy
    const string lc_param = lower_case_copy(param);
 
    if (lc_param==".false."){
        return false;
    } else if  (lc_param==".true."){
        return true;
    } else {
        printf("Error, couldn't parse %s \n", param.c_str());
        return false;
    }
}
 
static inline void change_D_to_E(string& param){
    for (int i = 0; i<param.size(); i++)
        if (param[i]=='D' || param[i]=='d') param[i]='e';
}
 
template<>
int string_to_param<int>(string& param){
    change_D_to_E(param);
    return stoi(param);
}
 
template<>
float string_to_param<float>(string& param){
    change_D_to_E(param);
    return stof(param);
}
 
template<>
double string_to_param<double>(string& param){
    change_D_to_E(param);
    return stod(param);
}
 
template<>
string string_to_param<string>(string& param){
    // Remove the quotes
    return param.substr(1,param.size()-2);
}
 
 
template<typename T>
int find_case_insensitive_name_match(vector<T>& vec, const string& str){
    // Make lower case version
    const string lc_str = lower_case_copy(str);
 
    // Locate the requested parameter
    typename vector<T>::iterator it = vec.begin();
    while (it!=vec.end()) {
        if (lower_case_copy((*it).name)==str) break;
        ++it;
    }
 
    if (it != vec.end())
        return distance(vec.begin(), it);
    else{
        return -1;
    }
}
 
class NamelistReader{
    vector<NameList> namelists;
    int namelist_index;
    bool use_all;
    bool modifiable;
 
    template<class T>
    void parse_lines(T& newfile, const string& filename){
        const bool verbose=false;
        string line;
        Expect expect = Ampersand;
        int i_line=0;
        while(getline(newfile, line)){ //read data from file object and put it into string.
            i_line++;
            trim(line); // Remove leading and trailing whitespace
            for (string::size_type i = 0; i < line.size(); i++){
                if (line[i]=='!'){
                    // Comment has begun
                    break;
                }
                if (expect==Ampersand){
                    if (line[i]=='&'){
                        expect=NLName;
                    }
                } else if (expect==NLName){
                    string word = get_first_word(line,i);
                    if (word.size()>0){ // Found namelist name
                        expect = ParaNameOrEnd;
                        namelists.push_back(NameList(word));
                        if (verbose) cout << "Found namelist: " << word << "\n";
                        break;
                    }
                } else if(expect==ParaNameOrEnd){
                    if (line[i]=='/'){ // End of namelist
                        expect=Ampersand;
                        break;
                    }
 
                    string word = get_first_word(line,i);
                    if (word.size()>0){
                        i+=word.size()-1;
                        expect = Equals;
                        namelists[namelists.size()-1].add_param(word);
                        if (verbose) cout << "  Found parameter: " << word << "\n";
                    }
                } else if(expect==Equals){
                    if (line[i]=='='){
                        expect=Value;
                    }
                } else if(expect==Value || expect == ValueOrEOL){
                    string word = get_first_value(line,i);
                    if (word.size()>0){
                        i+=word.size()-1;
                        expect = ValueOrEOL;
                        namelists[namelists.size()-1].add_value(word);
                        if (verbose) cout << "    Found Value: " << word << "\n";
                    }
                }
            }
            // Got to end of line
            if (expect==NLName){
                printf("\nParse failure reading %s at Line %d. Failed to find name of namelist.\n", filename.c_str(), i_line);
                return;
            } else if(expect==Equals){
                printf("\nParse failure reading %s at Line %d. Expected parameter assignment.\n", filename.c_str(), i_line);
                return;
            } else if(expect==Value){
                printf("\nParse failure reading %s at Line %d. Couldn't parse value assignment.\n", filename.c_str(), i_line);
                return;
            }
            // Hit EOL, now expecting next parameter
            if (expect==ValueOrEOL) expect = ParaNameOrEnd;
        }
    }
 
    void load(const string& filename){
        fstream newfile;
        newfile.open(filename,ios::in); //open a file to perform read operation using file object
        if (!newfile.is_open()) return; //checking whether the file is open
 
        parse_lines(newfile,filename);
 
        newfile.close(); //close the file object.
    }
 
    void load_from_string(const string& str){
        istringstream f(str.c_str());
 
        parse_lines(f,"string input");
    }
 
    public:
 
    enum Options{
        Optional=0, // Namelist is optional, use the default of any requested parameter if the namelist is not present
        Required=1
    };
 
    NamelistReader(const string& filename)
        : namelist_index(-1), use_all(false), modifiable(false)
    {
        load(filename);
    }
 
    NamelistReader(const string& str_name, ReadFrom read_from)
        : namelist_index(-1), use_all(false), modifiable(false)
    {
        if (read_from==ReadFromFile){
            load(str_name);
        }else{
            load_from_string(str_name);
        }
    }
 
    NamelistReader(Create create)
        : namelist_index(-1), use_all(false), modifiable(false)
    {
        if (create==CreateManually) modifiable = true;
    }
 
    void enable_modifications(){
        modifiable = true;
    }
 
    void add_namelist(const string& namelist){
        if (modifiable){
            namelists.push_back(NameList(namelist));
            namelist_index = namelists.size()-1; // Focus to the new namelist
        } else {
            printf("Warning: 'add_namelist' ignored, only valid if NamelistReader is in CreateManually mode");
        }
    }
 
    void add_to_namelist(const string& param, const string& val){
        if (modifiable){
            namelists[namelist_index].add_param(param);
            namelists[namelist_index].add_value(val);
        } else {
            printf("Warning: 'add_to_namelist' ignored, only valid if NamelistReader is in CreateManually mode");
        }
    }
 
    void add_to_param(const string& val){
        if (modifiable){
            namelists[namelist_index].add_value(val);
        } else {
            printf("Warning: 'add_to_param' ignored, only valid if NamelistReader is in CreateManually mode");
        }
    }
 
    bool check_all_used(){
        int n_unused=0;
        for (vector<NameList>::iterator nl = namelists.begin(); nl != namelists.end(); ++nl) {
            for (vector<Param>::iterator param = nl->params.begin(); param != nl->params.end(); ++param ) {
                if (param->used==false){
                    printf("Warning: '%s' was present in '%s' but was not used.\n",param->name.c_str(), nl->name.c_str());
                    n_unused++;
                }
            }
        }
        return (n_unused==0);
    }
 
    bool namelist_present(const string& namelist){
        return (find_case_insensitive_name_match(namelists, namelist)!=-1);
    }
 
    void use_namelist(const string& namelist, Options required = Required){
        namelist_index = find_case_insensitive_name_match(namelists, namelist);
        if(namelist_index==-1){
            if(required==Required){
                printf("\nNamelist '%s' not found in the file!",namelist.c_str());
                exit(1);
            }else{
                // Use -2 to indicate that the defaults can be safely used if
                // the namelist is not present
                namelist_index = -2;
            }
        }
    }
 
    bool present(const string& param){
        if(namelist_index==-1){
            printf("\nNeed to choose which namelist to use with use_namelist(const std::string&)!\n");
        }else if(namelist_index==-2){
            return false; // Namelist not present so param is also not present
        }
 
        // Locate the requested parameter
        return (find_case_insensitive_name_match(namelists[namelist_index].params, param)!=-1);
    }
 
    template <typename T>
    T get(const string& param, const T default_val, int val_ind=0){
        if (namelist_index==-1){
            printf("\nNeed to choose which namelist to use with use_namelist(const std::string&)!\n");
        }else if(namelist_index==-2){
            return default_val; // Namelist not present so return default
        }
 
        // Locate the requested parameter
        int param_index = find_case_insensitive_name_match(namelists[namelist_index].params, param);
        if(param_index==-1){
            return default_val;
        }
 
        namelists[namelist_index].params[param_index].used=true;
 
        if (val_ind>=0 && val_ind<namelists[namelist_index].params[param_index].values.size()){
            string str_var = namelists[namelist_index].params[param_index].values[val_ind];
            return string_to_param<T>(str_var);
        } else {
            printf("\nParameter '%s' in namelist '%s' didn't have enough values!",param.c_str(),namelists[namelist_index].name.c_str());
            exit(1);
            return default_val;
        }
    }
 
    template <typename T>
    T get_required(const string& param, int val_ind=0){
        if (namelist_index==-1){
            printf("\nNeed to choose which namelist to use with use_namelist(const std::string&)!\n");
            exit(1);
        }else if(namelist_index==-2){
            printf("\nParameter '%s' not found since the namelist was not found.\n",param.c_str(),namelists[namelist_index].name.c_str());
            exit(1);
        }
 
        // Locate the requested parameter
        int param_index = find_case_insensitive_name_match(namelists[namelist_index].params, param);
        if(param_index==-1){
            printf("\nParameter '%s' not found in namelist '%s'!",param.c_str(),namelists[namelist_index].name.c_str());
            exit(1);
        }
 
        namelists[namelist_index].params[param_index].used=true;
 
        if (val_ind>=0 && val_ind<namelists[namelist_index].params[param_index].values.size()){
            string str_var = namelists[namelist_index].params[param_index].values[val_ind];
            return string_to_param<T>(str_var);
        } else {
            printf("\nParameter '%s' in namelist '%s' didn't have enough values!",param.c_str(),namelists[namelist_index].name.c_str());
            exit(1);
        }
    }
};
 
}
#endif