src/optparse/TypedOptionParser.cpp

Go to the documentation of this file.

//
// C++ Implementation: %{MODULE}
//
// Description:
//
//
// Author: %{AUTHOR} <%{EMAIL}>, (C) %{YEAR}
//
// Copyright: See COPYING file that comes with this distribution
//
//

#include <sstream>
#include "TypedOptionParser.h"

namespace optparse {

using namespace std;

void TypedOptionParser::add_option(Teuchos::ParameterList& params,
                std::string shrt_flag, std::string lng_flag,
                std::string destination, std::string help, action_t act,
                std::string allowed_values) {
    // Find sublist/key from destination.
    string key(destination);
    Teuchos::ParameterList* sublist = &params;
    size_t dot_pos;
    while((dot_pos = key.find('.')) != string::npos) {
        sublist = &sublist->sublist(key.substr(0, dot_pos));
        key = key.substr(dot_pos+1, string::npos); 
    }
    
    type_t type;
    ostringstream buf;
    if (sublist->isType<int>(key)) {
        type = INT;
        buf << sublist->get<int>(key);
    } else if (sublist->isType<double>(key)) {
        type = DOUBLE;
        buf << sublist->get<double>(key);
    } else if (sublist->isType<string>(key)) {
        type = STRING;
        buf << sublist->get<string>(key);
    } else if (sublist->isType<bool>(key)) {
        type = BOOL;
        if (sublist->get<bool>(key))
            buf << '1';
        else
            buf << '0';
    } else
        assert(false);
    string default_value = buf.str();        
    OptionParser::add_option(shrt_flag, lng_flag, destination, help, act, type, default_value, allowed_values);
}

void TypedOptionParser::set_parameter_list(Teuchos::ParameterList& params) {
    for (OptionParser::options_type::iterator it = options.begin(); it != options.end(); ++ it) {
        // Descend into sublists
        string key(it->first);
        Teuchos::ParameterList* sublist = &params;
        size_t dot_pos;
        while((dot_pos = key.find('.')) != string::npos) {
            sublist = &sublist->sublist(key.substr(0, dot_pos));
            key = key.substr(dot_pos+1, string::npos); 
        }
        // Split val::type
        string val(it->second);
        size_t colon_pos = val.find(':');
        assert(colon_pos != string::npos);
        string type(val.substr(colon_pos+1, string::npos));
        val = val.substr(0, colon_pos);
        // Set parameter
        if (type == "STRING")
            sublist->set(key, val);
        else if (type == "DOUBLE")
            sublist->set(key, atof(val.c_str()));
        else if (type == "INT")
            sublist->set(key, atoi(val.c_str()));
        else if (type == "BOOL") {
            sublist->set(key, val != "0");
        } else
            assert(false);
    }
}

string TypedOptionParser::get_option(std::string option_name) {
    string arg(options[option_name]);
    size_t colon_pos = arg.find(':');
    return arg.substr(0, colon_pos);
}

void TypedOptionParser::set_option(Option& option, string argument) {
    if (option.is_allowed(argument))
        options[option.destination] = argument + ":" + type2string(option.type_);
    else
        throw OptionError(option.shrt_flag + " " + option.lng_flag, "Invalid argument for option");
}

} // namespace optparse

---